it-swarm.com.de

Was ist der Unterschied zwischen den Funktionen RANK () und DENSE_RANK () in Oracle?

Was ist der Unterschied zwischen den Funktionen RANK() und DENSE_RANK()? Wie kann ich das n-te Gehalt in der folgenden emptbl-Tabelle ermitteln?

DEPTNO  EMPNAME    SAL
------------------------------
10       rrr    10000.00
11       nnn    20000.00
11       mmm    5000.00
12       kkk    30000.00
10       fff    40000.00
10       ddd    40000.00
10       bbb    50000.00
10       ccc    50000.00

Wenn in den Tabellendaten nulls vorhanden ist, was passiert, wenn ich nth Gehalt ermitteln möchte?

111
user1357722

RANK gibt Ihnen das Ranking innerhalb Ihrer bestellten Partition an. Krawatten erhalten denselben Rang, wobei die nächsten Ranglisten übersprungen werden. Wenn Sie also 3 Gegenstände auf Rang 2 haben, wird der nächste Rang 5 angezeigt.

DENSE_RANK gibt Ihnen erneut das Ranking innerhalb Ihrer geordneten Partition an, die Ränge sind jedoch aufeinanderfolgend. Es werden keine Ränge übersprungen, wenn es mehrere Ränge gibt.

Bei Nullen hängt es von der ORDER BY-Klausel ab. Hier ist ein einfaches Testskript, mit dem Sie sehen können, was passiert:

with q as (
select 10 deptno, 'rrr' empname, 10000.00 sal from dual union all
select 11, 'nnn', 20000.00 from dual union all
select 11, 'mmm', 5000.00 from dual union all
select 12, 'kkk', 30000 from dual union all
select 10, 'fff', 40000 from dual union all
select 10, 'ddd', 40000 from dual union all
select 10, 'bbb', 50000 from dual union all
select 10, 'xxx', null from dual union all
select 10, 'ccc', 50000 from dual)
select empname, deptno, sal
     , rank() over (partition by deptno order by sal nulls first) r
     , dense_rank() over (partition by deptno order by sal nulls first) dr1
     , dense_rank() over (partition by deptno order by sal nulls last) dr2
 from q; 

EMP     DEPTNO        SAL          R        DR1        DR2
--- ---------- ---------- ---------- ---------- ----------
xxx         10                     1          1          4
rrr         10      10000          2          2          1
fff         10      40000          3          3          2
ddd         10      40000          3          3          2
ccc         10      50000          5          4          3
bbb         10      50000          5          4          3
mmm         11       5000          1          1          1
nnn         11      20000          2          2          2
kkk         12      30000          1          1          1

9 rows selected.

Hier ist ein Link zu einer guten Erklärung und einigen Beispielen.

184
DCookie

Dieser Artikel erklärt es schön. Im Wesentlichen können Sie es als solches betrachten:

CREATE TABLE t AS
SELECT 'a' v FROM dual UNION ALL
SELECT 'a'   FROM dual UNION ALL
SELECT 'a'   FROM dual UNION ALL
SELECT 'b'   FROM dual UNION ALL
SELECT 'c'   FROM dual UNION ALL
SELECT 'c'   FROM dual UNION ALL
SELECT 'd'   FROM dual UNION ALL
SELECT 'e'   FROM dual;

SELECT
  v,
  ROW_NUMBER() OVER (ORDER BY v) row_number,
  RANK()       OVER (ORDER BY v) rank,
  DENSE_RANK() OVER (ORDER BY v) dense_rank
FROM t
ORDER BY v;

Das obige wird ergeben:

+---+------------+------+------------+
| V | ROW_NUMBER | RANK | DENSE_RANK |
+---+------------+------+------------+
| a |          1 |    1 |          1 |
| a |          2 |    1 |          1 |
| a |          3 |    1 |          1 |
| b |          4 |    4 |          2 |
| c |          5 |    5 |          3 |
| c |          6 |    5 |          3 |
| d |          7 |    7 |          4 |
| e |          8 |    8 |          5 |
+---+------------+------+------------+

In Worten

  • ROW_NUMBER() schreibt jeder Zeile einen eindeutigen Wert zu
  • RANK() schreibt dieselbe Zeilennummer auf denselben Wert zurück, wobei "Löcher" übrig bleiben.
  • DENSE_RANK() schreibt dieselbe Zeilennummer auf denselben Wert, ohne "Löcher" zu hinterlassen.
73
Lukas Eder
SELECT empno,
       deptno,
       sal,
       RANK() OVER (PARTITION BY deptno ORDER BY sal) "rank"
FROM   emp;

     EMPNO     DEPTNO        SAL       rank
---------- ---------- ---------- ----------
      7934         10       1300          1
      7782         10       2450          2
      7839         10       5000          3
      7369         20        800          1
      7876         20       1100          2
      7566         20       2975          3
      7788         20       3000          4
      7902         20       3000          4
      7900         30        950          1
      7654         30       1250          2
      7521         30       1250          2
      7844         30       1500          4
      7499         30       1600          5
      7698         30       2850          6


SELECT empno,
       deptno,
       sal,
       DENSE_RANK() OVER (PARTITION BY deptno ORDER BY sal) "rank"
FROM   emp;

     EMPNO     DEPTNO        SAL       rank
---------- ---------- ---------- ----------
      7934         10       1300          1
      7782         10       2450          2
      7839         10       5000          3
      7369         20        800          1
      7876         20       1100          2
      7566         20       2975          3
      7788         20       3000          4
      7902         20       3000          4
      7900         30        950          1
      7654         30       1250          2
      7521         30       1250          2
      7844         30       1500          3
      7499         30       1600          4
      7698         30       2850          5
7
Anant_00

rank () : Wird verwendet, um einen Datensatz innerhalb einer Gruppe von Zeilen zu ordnen.

dense_rank () : Die DENSE_RANK-Funktion verhält sich wie die RANK-Funktion, außer dass sie aufeinanderfolgende Ränge zuordnet.

Abfrage -

select 
    ENAME,SAL,RANK() over (order by SAL) RANK
from 
    EMP;

Ausgabe -

+--------+------+------+
| ENAME  | SAL  | RANK |
+--------+------+------+
| SMITH  |  800 |    1 |
| JAMES  |  950 |    2 |
| ADAMS  | 1100 |    3 |
| MARTIN | 1250 |    4 |
| WARD   | 1250 |    4 |
| TURNER | 1500 |    6 |
+--------+------+------+

Abfrage - 

select 
    ENAME,SAL,dense_rank() over (order by SAL) DEN_RANK
from 
    EMP;

Ausgabe -

+--------+------+-----------+
| ENAME  | SAL  |  DEN_RANK |
+--------+------+-----------+
| SMITH  |  800 |         1 |
| JAMES  |  950 |         2 |
| ADAMS  | 1100 |         3 |
| MARTIN | 1250 |         4 |
| WARD   | 1250 |         4 |
| TURNER | 1500 |         5 |
+--------+------+-----------+
5
Shine
select empno
       ,salary
       ,row_number() over(order by salary desc) as Serial
       ,Rank() over(order by salary desc) as rank
       ,dense_rank() over(order by salary desc) as denseRank
from emp ;

Row_number() -> Wird zur Generierung der Seriennummer verwendet

Dense_rank() gibt den fortlaufenden Rang an, aber der Rang überspringt den Rang im Falle eines Rangkampfs.

2

Der einzige Unterschied zwischen den Funktionen RANK () und DENSE_RANK () besteht in Fällen, in denen ein „Unentschieden“ vorliegt. d. h. in Fällen, in denen mehrere Werte in einem Satz die gleiche Rangfolge haben. In solchen Fällen weist RANK () den Werten im Set nicht aufeinanderfolgende "Ränge" zu (was bei einem Gleichstand zu Lücken zwischen den ganzzahligen Rangwerten führt), wohingegen DENSE_RANK () den Werten in der Dose aufeinanderfolgende Ränge zuweisen gesetzt (damit bei einem Gleichstand keine Lücken zwischen den ganzzahligen Rangwerten entstehen).

Betrachten Sie beispielsweise die Menge {25, 25, 50, 75, 75, 100}. Für ein solches Set gibt RANK () {1, 1, 3, 4, 4, 6} zurück (beachten Sie, dass die Werte 2 und 5 übersprungen werden), während DENSE_RANK () {1,1,2,3, 3,4}.

2
Salman Lone

Die SQL-Funktion Rank () generiert den Rang der Daten innerhalb einer geordneten Menge von Werten. Der nächste Rang nach dem vorherigen Rang ist jedoch Reihennummer dieser bestimmten Zeile. Auf der anderen Seite generiert die SQL-Funktion Dense_Rank () die nächste Zahl, anstatt die Zeilennummer zu erzeugen. Unten ist das SQL-Beispiel, das das Konzept verdeutlicht:

Select ROW_NUMBER() over (order by Salary) as RowNum, Salary, 
RANK() over (order by Salary) as Rnk, 
DENSE_RANK() over (order by Salary) as DenseRnk from (
Select 1000 as Salary union all
Select 1000 as Salary union all
Select 1000 as Salary union all
Select 2000 as Salary union all
Select 3000 as Salary union all
Select 3000 as Salary union all
Select 8000 as Salary union all
Select 9000 as Salary) A

Es wird folgende Ausgabe erzeugen:

----------------------------
RowNum  Salary  Rnk DenseRnk
----------------------------
1       1000    1   1
2       1000    1   1
3       1000    1   1
4       2000    4   2
5       3000    5   3
6       3000    5   3
7       8000    7   4
8       9000    8   5

Rang und Dichte Rang gibt den Rang im partitionierten Datensatz an.

Rank (): Sie erhalten keine fortlaufenden Ganzzahlen.

Dense_rank (): Gibt Ihnen fortlaufende Ganzzahlen.

enter image description here

In der obigen Abbildung ist der Rang von 10008 Zip 2 nach der Funktion dense_rank () und 24 nach der Funktion rank (), da die Zeilennummer berücksichtigt wird.

0
Tutu Kumari