SQL / mysql - Sélectionnez distinct / UNIQUE mais retournez toutes les colonnes?

SELECT DISTINCT field1, field2, field3, ......   FROM table

J'essaye d'accomplir l'instruction sql suivante mais je veux qu'elle retourne toutes les colonnes est-ce possible? Quelque chose comme:

SELECT DISTINCT field1, * from table

Vous recherchez un groupe par:

select *
from table
group by field1

Qui peut parfois être écrit avec une déclaration distincte:

select distinct on field1 *
from table

Sur la plupart des plates-formes, cependant, aucun des éléments ci-dessus ne fonctionnera car le comportement sur les autres colonnes n'est pas spécifié. (Le premier fonctionne dans MySQL, si c'est ce que vous utilisez.)

Vous pouvez récupérer les champs distincts et vous contenter de choisir une seule ligne arbitraire à chaque fois.

Sur certaines plates-formes (par exemple PostgreSQL, Oracle, T-SQL), cela peut être fait directement en utilisant des fonctions de fenêtre:

select *
from (
   select *,
          row_number() over (partition by field1 order by field2) as row_number
   from table
   ) as rows
where row_number = 1

Sur d'autres (MySQL, SQLite), vous devrez écrire des sous-requêtes qui vous feront joindre la table entière avec elle-même ( exemple ), donc pas recommandé.

D'après la formulation de votre question, je comprends que vous souhaitez sélectionner les valeurs distinctes pour un champ donné et pour chacune de ces valeurs avoir toutes les autres valeurs de colonne dans la même ligne répertoriées. La plupart des SGBD ne permettent pas cela avec ni DISTINCTni GROUP BY, car le résultat n'est pas déterminé.

Pensez-y comme ceci: si votre field1se produit plus d'une fois, quelle valeur de field2sera répertoriée (étant donné que vous avez la même valeur pour field1dans deux lignes mais deux valeurs distinctes de field2dans ces deux lignes).

Vous pouvez cependant utiliser des fonctions d'agrégation (explicitement pour chaque champ que vous souhaitez afficher) et utiliser un GROUP BYau lieu de DISTINCT:

SELECT field1, MAX(field2), COUNT(field3), SUM(field4), .... FROM table GROUP BY field1

Si j'ai bien compris votre problème, il est similaire à celui que je viens d'avoir. Vous voulez pouvoir limiter l'utilisabilité de DISTINCT à un champ spécifié, plutôt que de l'appliquer à toutes les données.

Si vous utilisez GROUP BY sans fonction d'agrégation, quel champ que vous regroupez GROUP BY sera votre fichier DISTINCT.

Si vous faites votre requête:

SELECT * from table GROUP BY field1;

Il affichera tous vos résultats sur la base d'une seule instance de field1.

Par exemple, si vous avez une table avec nom, adresse et ville. Une seule personne a plusieurs adresses enregistrées, mais vous voulez juste une seule adresse pour la personne, vous pouvez interroger comme suit:

SELECT * FROM persons GROUP BY name;

Le résultat sera qu'une seule instance de ce nom apparaîtra avec son adresse, et l'autre sera omise de la table résultante. Attention: si vos fichiers ont des valeurs atomiques telles que firstName, lastName que vous souhaitez regrouper par les deux.

SELECT * FROM persons GROUP BY lastName, firstName;

car si deux personnes ont le même nom de famille et que vous ne les regroupez que par nom, l'une de ces personnes sera omise des résultats. Vous devez garder ces choses en considération. J'espère que cela t'aides.

SELECT  c2.field1 ,
        field2
FROM    (SELECT DISTINCT
                field1
         FROM   dbo.TABLE AS C
        ) AS c1
        JOIN dbo.TABLE AS c2 ON c1.field1 = c2.field1

Voilà une très bonne question. J'ai déjà lu quelques réponses utiles ici, mais je peux probablement ajouter une explication plus précise.

La réduction du nombre de résultats de requête avec une instruction GROUP BY est facile tant que vous ne recherchez pas d'informations supplémentaires. Supposons que vous obteniez le tableau suivant «emplacements».

--country-- --city--
 France      Lyon
 Poland      Krakow
 France      Paris
 France      Marseille
 Italy       Milano

Maintenant, la requête

SELECT country FROM locations
GROUP BY country

aura pour résultat:

--country--
 France
 Poland
 Italy

Cependant, la requête suivante

SELECT country, city FROM locations
GROUP BY country

... lance une erreur dans MS SQL, car comment votre ordinateur pourrait-il savoir laquelle des trois villes françaises "Lyon", "Paris" ou "Marseille" vous voulez lire dans le champ à droite de "France"?

Afin de corriger la deuxième requête, vous devez ajouter ces informations. Pour ce faire, vous pouvez utiliser les fonctions MAX () ou MIN () en sélectionnant la valeur la plus grande ou la plus petite parmi tous les candidats. MAX () et MIN () ne s'appliquent pas seulement aux valeurs numériques, mais comparent également l'ordre alphabétique des valeurs de chaîne.

SELECT country, MAX(city) FROM locations
GROUP BY country

aura pour résultat:

--country-- --city--
 France      Paris
 Poland      Krakow
 Italy       Milano

ou:

SELECT country, MIN(city) FROM locations
GROUP BY country

aura pour résultat:

--country-- --city--
 France      Lyon
 Poland      Krakow
 Italy       Milano

Ces fonctions sont une bonne solution tant que vous êtes d'accord avec la sélection de votre valeur dans les deux extrémités de l'ordre alphabétique (ou numérique). Mais que faire si ce n'est pas le cas? Supposons que vous ayez besoin d'une valeur avec une certaine caractéristique, par exemple en commençant par la lettre «M». Maintenant, les choses se compliquent.

La seule solution que j'ai pu trouver jusqu'à présent est de mettre l'intégralité de votre requête dans une sous-requête et de construire la colonne supplémentaire en dehors d'elle à la main:

SELECT
     countrylist.*,
     (SELECT TOP 1 city
     FROM locations
     WHERE
          country = countrylist.country
          AND city like 'M%'
     )
FROM
(SELECT country FROM locations
GROUP BY country) countrylist

aura pour résultat:

--country-- --city--
 France      Marseille
 Poland      NULL
 Italy       Milano

Grande question @aryaxt - vous pouvez dire que c'était une excellente question parce que vous l'avez posée il y a 5 ans et je suis tombée dessus aujourd'hui en essayant de trouver la réponse!

J'ai juste essayé de modifier la réponse acceptée pour l'inclure, mais au cas où ma modification ne se ferait pas dans:

Si votre table n'était pas si grande et en supposant que votre clé primaire était un entier à incrémentation automatique, vous pourriez faire quelque chose comme ceci:

SELECT 
  table.*
FROM table
--be able to take out dupes later
LEFT JOIN (
  SELECT field, MAX(id) as id
  FROM table
  GROUP BY field
) as noDupes on noDupes.id = table.id
WHERE
  //this will result in only the last instance being seen
  noDupes.id is not NULL

Essayer

SELECT table.* FROM table 
WHERE otherField = 'otherValue'
GROUP BY table.fieldWantedToBeDistinct
limit x

Vous pouvez le faire avec une WITHclause.

Par exemple:

WITH c AS (SELECT DISTINCT a, b, c FROM tableName)
SELECT * FROM tableName r, c WHERE c.rowid=r.rowid AND c.a=r.a AND c.b=r.b AND c.c=r.c

Cela vous permet également de sélectionner uniquement les lignes sélectionnées dans la WITHrequête de clauses.

Pour SQL Server, vous pouvez utiliser le dense_rank et les fonctions de fenêtrage supplémentaires pour obtenir toutes les lignes ET les colonnes avec des valeurs dupliquées sur les colonnes spécifiées. Voici un exemple...

with t as (
    select col1 = 'a', col2 = 'b', col3 = 'c', other = 'r1' union all
    select col1 = 'c', col2 = 'b', col3 = 'a', other = 'r2' union all
    select col1 = 'a', col2 = 'b', col3 = 'c', other = 'r3' union all
    select col1 = 'a', col2 = 'b', col3 = 'c', other = 'r4' union all
    select col1 = 'c', col2 = 'b', col3 = 'a', other = 'r5' union all
    select col1 = 'a', col2 = 'a', col3 = 'a', other = 'r6'
), tdr as (
    select 
        *, 
        total_dr_rows = count(*) over(partition by dr)
    from (
        select 
            *, 
            dr = dense_rank() over(order by col1, col2, col3),
            dr_rn = row_number() over(partition by col1, col2, col3 order by other)
        from 
            t
    ) x
)

select * from tdr where total_dr_rows > 1

Cela prend un nombre de lignes pour chaque combinaison distincte de col1, col2 et col3.

select min(table.id), table.column1
from table 
group by table.column1

SELECT *
FROM tblname
GROUP BY duplicate_values
ORDER BY ex.VISITED_ON DESC
LIMIT 0 , 30

dans ORDER BYje viens de mettre l'exemple ici, vous pouvez également ajouter un champ ID dans ce

J'ai trouvé cela ailleurs ici, mais c'est une solution simple qui fonctionne:

 WITH cte AS /* Declaring a new table named 'cte' to be a clone of your table */
 (SELECT *, ROW_NUMBER() OVER (PARTITION BY id ORDER BY val1 DESC) AS rn
 FROM MyTable /* Selecting only unique values based on the "id" field */
 )
 SELECT * /* Here you can specify several columns to retrieve */
 FROM cte
 WHERE rn = 1

Ajoutez GROUP BY au champ que vous souhaitez vérifier pour les doublons auxquels votre requête pourrait ressembler

SELECT field1, field2, field3, ......   FROM table GROUP BY field1

field1 sera vérifié pour exclure les enregistrements en double

ou vous pouvez interroger comme

SELECT *  FROM table GROUP BY field1

les enregistrements en double du champ1 sont exclus de SELECT

Incluez simplement tous vos champs dans la clause GROUP BY.

Cela peut être fait par requête interne

$query = "SELECT * 
            FROM (SELECT field
                FROM table
                ORDER BY id DESC) as rows               
            GROUP BY field";

SELECT * from table where field in (SELECT distinct field from table)

SELECT DISTINCT FIELD1, FIELD2, FIELD3 FROM TABLE1 fonctionne si les valeurs des trois colonnes sont uniques dans la table.

Si, par exemple, vous avez plusieurs valeurs identiques pour le prénom, mais que le nom et les autres informations dans les colonnes sélectionnées sont différents, l'enregistrement sera inclus dans le jeu de résultats.

Je suggère d'utiliser

SELECT  * from table where field1 in 
(
  select distinct field1 from table
)

De cette façon, si vous avez la même valeur dans field1 sur plusieurs lignes, tous les enregistrements seront retournés.