Discussion :

[Patrice Henrio]

Bonjur,
J'ai une table avec trois attributs ID,LO,LA. ID est la clé. Je cherche les pseudo doublons (LO,LA).
J'ai utilisé cette requête (qui fonctionne).
J'ai besoin d'un conseil en SQL (encore). J'ai réussi à obtenir ce que je voulais mais je me demande s'il n'y a pas plus efficace.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
select *
from points t1
join(SELECT concat(Longitude, ';',latitude) as lola
       from Points
       group by longitude, latitude
       having count(lola) > 1) t2
on concat(t1.LONGITUDE,';',LATITUDE) = t2.lola
order by longitude, latitude, id ;

Le résultat reste rapide car avec une table de 50000 tuples, j'ai le résultat en 10 s.

Ma question est : est-il possible de faire la même chose sans passer par concat ?

Merci.

[escartefigue]

Bonjour

vous pouviez faire plus simple : une auto jointure avec égalité sur LO et LA et inégalité sur ID
Si vous avez un index sur LO+LA (sans ID) ce sera beaucoup plus rapide qu'un concat qui lui ne sera jamais sargable

[aieeeuuuuu]

Bonjour,

Vous pouvez plus simplement faire un teste d'existance :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
select *
from points t1
where exists (
    select 1
    from points t2
    where T2.longitude = T1.longitude
    and T2.latitude = T1.latitude
    and T2.id <> T1.id
)

Avec les bons index sur les coordonnées, la réponse devrait être très rapide pour 50000 lignes.

[kolodz]

Je vais peut-être paraitre idiot, mais j'ai tendance à faire ce genre de requête :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
select longitude, latitude, count(*)
    from points
    group by longitude , latitude
    having count(*)>1
    order by count(*) desc;

Cordialement,
Patrick Kolodziejczyk.

[escartefigue]

Ca fonctionne aussi mais c'est plus gourmand en ressources à cause du groupage (et de l'order by mais qui n'est pas requis)

[kolodz]

J'ai fait la comparaison entre la requête de aieeeuuuuu et ma requête encapsulé dans un count(*) :
aieeeuuuuu =>0.993 secondes
kolodz => 0.191 secondes

Sur 205119 enregistrements dont 138044 doublons sur 51553 association différentes.
Avec un table indexé correctement.

[Waldar]

@kolodz, les deux requêtes ne renvoient pas la même chose, difficile de faire une comparaison, il faut refaire la jointure avec la table initiale pour récupérer la liste des pseudos-doublons.

[escartefigue]

La dégradation des perfs peut être exponentielle lorsque les volumes augmentent, avec 200 000 lignes le test n'est pas significatif.

[kolodz]

La dégradation des perfs peut être exponentielle lorsque les volumes augmentent, avec 200 000 lignes le test n'est pas significatif.

C'est juste 4 fois plus que le test initial réalisé par Patrice Henrio.

@Waldar En effet, mais on reste très en dessous des 10 secondes de la requête de base présenté.

[escartefigue]

La requete initiale est à peu près ce qu'on peut faire de pire à cause des fonctions de colonne qui la rendent non sargable
Ma réponse concernait la phrase "...j'ai tendance à faire ce genre de requête " qui accompagnait la requête avec groupage

Cette tendance est fâcheuse SI on considère des tables volumineuses, avec quelques dizaines de millions de lignes par exemple
Là la différence de mesure sera certainement très significative

[aieeeuuuuu]

Je ne serait pas aussi péremptoire. Car la requête de kolodz a tout de même l'avantage d'éviter l'auto jointure ou la sous requete, certainement plus consommatrices que le groupage (surtout si un index existe : le groupage aura alors un coup très bas)

Mais s'il faut récupérer d'autre colonnes, alors il faut malgré tout ajouter la jointure...

bref, la meilleure requete dépendra donc du besoin (qui n'a pas été clairement défini), mais aussi de la volumétrie, de la répartition des données, ...