requête sql distinctes avec la fonction Row_Number

Je me bats avec le mot clé distinct dans sql.
Je veux juste afficher tous les numéros de ligne unique (distinct) les valeurs dans une colonne & j'ai donc essayé:

SELECT distinct id, ROW_NUMBER() OVER (ORDER BY  id) AS RowNum
                             FROM table
                             where fid = 64

cependant le code ci-dessous me donner la distinct valeurs:

SELECT distinct id FROM table where fid = 64

mais quand il a essayé avec Row_Number.

alors il n'est pas de travail.

InformationsquelleAutor objectWithoutClass | 2013-08-08

distinct sql

43

Utiliser ceci:
```
SELECT *, ROW_NUMBER() OVER (ORDER BY id) AS RowNum FROM
    (SELECT DISTINCT id FROM table WHERE fid = 64) Base
```
et de mettre la "sortie" d'une requête comme "entrée" de l'autre.

À l'aide de la CTE:
```
; WITH Base AS (
    SELECT DISTINCT id FROM table WHERE fid = 64
)

SELECT *, ROW_NUMBER() OVER (ORDER BY id) AS RowNum FROM Base
```
Les deux requêtes doivent être équivalent.

Techniquement, vous pourriez
```
SELECT DISTINCT id, ROW_NUMBER() OVER (PARTITION BY id ORDER BY id) AS RowNum 
    FROM table
    WHERE fid = 64
```
mais si vous augmentez le nombre de domaines DISTINCTS, vous devez mettre toutes ces champs dans le PARTITION BY, par exemple, les
```
SELECT DISTINCT id, description,
    ROW_NUMBER() OVER (PARTITION BY id, description ORDER BY id) AS RowNum 
    FROM table
    WHERE fid = 64
```
J'espère même que vous comprendre que vous êtes aller à l'encontre de la norme conventions de nommage ici, id devrait probablement être une clé primaire, unique par définition, un DISTINCT serait inutile, sauf si vous couplé à la requête avec certains JOINs/UNION ALL...

InformationsquelleAutor xanatos
83

Cela peut être fait très simple, vous avez été assez proche déjà
```
SELECT distinct id, DENSE_RANK() OVER (ORDER BY  id) AS RowNum
FROM table
WHERE fid = 64
```
InformationsquelleAutor t-clausen.dk

Cet article couvre une relation intéressante entre ROW_NUMBER() et DENSE_RANK() (le RANK() fonction n'est pas traitée de façon spécifique). Lorsque vous avez besoin d'un générés ROW_NUMBER() sur un SELECT DISTINCT déclaration, le ROW_NUMBER() va produire des valeurs distinctes avant ils sont enlevés par le DISTINCT mot clé. E. g. cette requête

SELECT DISTINCT
  v, 
  ROW_NUMBER() OVER (ORDER BY v) row_number
FROM t
ORDER BY v, row_number

... peut produire ce résultat (DISTINCT n'a pas d'effet):

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

Considérant que cette requête:

SELECT DISTINCT
  v, 
  DENSE_RANK() OVER (ORDER BY v) row_number
FROM t
ORDER BY v, row_number

... produit de ce que vous voulez probablement dans ce cas:

+---+------------+
| V | ROW_NUMBER |
+---+------------+
| a |          1 |
| b |          2 |
| c |          3 |
| d |          4 |
| e |          5 |
+---+------------+

Noter que le ORDER BY de la clause de la DENSE_RANK() fonction aura besoin de toutes les autres colonnes de la SELECT DISTINCT clause de travailler correctement.

Tous les trois fonctions en comparaison

L'utilisation de PostgreSQL /Sybase /syntaxe SQL standard (WINDOW clause):

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

... vous obtiendrez:

+---+------------+------+------------+
| 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 |
+---+------------+------+------------+

InformationsquelleAutor Lukas Eder

3

À l'aide de DISTINCT provoque des problèmes que vous ajoutez des champs et il peut également masquer des problèmes dans votre sélection. Utilisation GROUP BY comme une alternative comme ceci:
```
SELECT id
      ,ROW_NUMBER() OVER (ORDER BY  id) AS RowNum
  FROM table
 where fid = 64
 group by id
```
Ensuite, vous pouvez ajouter d'autres informations intéressantes à partir de votre sélectionner comme ceci:
```
,count(*) as thecount
```
ou
```
,max(description) as description
```
- Upvoted pour l'utilisation de group by. Mais je pense que partition by ne sera pas nécessaire ici.
- Bien sûr, vous avez raison. J'ai corrigé. Je n'ai aucune idée de ce à quoi je pensais quand je l'ai mis là.
InformationsquelleAutor Michael Potter

Comment au sujet de quelque chose comme

;WITH DistinctVals AS (
        SELECT  distinct id 
        FROM    table 
        where   fid = 64
    )
SELECT  id,
        ROW_NUMBER() OVER (ORDER BY  id) AS RowNum
FROM    DistinctVals

SQL Violon DÉMO

Vous pouvez également essayer de

SELECT distinct id, DENSE_RANK() OVER (ORDER BY  id) AS RowNum
FROM @mytable
where fid = 64

SQL Violon DÉMO

InformationsquelleAutor Adriaan Stander

Essayez ceci:

;WITH CTE AS (
               SELECT DISTINCT id FROM table WHERE fid = 64
             )
SELECT id, ROW_NUMBER() OVER (ORDER BY  id) AS RowNum
  FROM cte
 WHERE fid = 64

InformationsquelleAutor hims056

Essayer cette

SELECT distinct id
FROM  (SELECT id, ROW_NUMBER() OVER (ORDER BY  id) AS RowNum
      FROM table
      WHERE fid = 64) t

Ou de l'utilisation RANK() au lieu du numéro de ligne et de sélectionner les enregistrements DISTINCT rank

SELECT id
FROM  (SELECT id, ROW_NUMBER() OVER (PARTITION BY  id ORDER BY  id) AS RowNum
      FROM table
      WHERE fid = 64) t
WHERE t.RowNum=1

Cela revient aussi distinctes id

InformationsquelleAutor Nithesh

Vous devez vous connecter pour publier un commentaire.