Discussion :

[od125]

Bonjour , j'ai un problème lors de l'exécution de ma requête qui est la suivante :

Code :

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

1
2
3
4
 
select Nom_Ville
from Villes, Habitants
where  Habitants.Code_Ville=Villes.Code_Ville having  avg (Nb_Habitants)<Nb_Habitants;

ma base contient la table villes(Code_Villes,Nom_Ville,Nb_Habitants) et la table Habitants(Matric,Code_Ville,Nom)
je veux afficher les noms des villes qui ont plus que la moyenne des nombres d'habitants des villes , en exécutant ma requête j'ai eu l'erreur : not a group by expression
Merci

[ectap]

Bonjour,

Si ton SELECT contient autre chose que des fonctions d'agrégation il faut une clause GROUP BY

Dans ton cas le plus simple est de faire une sous requête qui calcule la moyenne du nombre d'habitants de toutes les villes
C'est aussi faisable avec AVG utilisée comme une fonction OLAP (cf http://lalystar.developpez.com/fonctionsAnalytiques)

Bonne Soirée

[Ikebukuro]

Si on peut mettre un Having sans Group By, ou un Group By sans Having, en général on met plutôt Group By puis Having car le Having filtre sur une fonction de groupe, en général introduite par le Group By.
Ici la fonction est avg(Nb_Habitants) mais elle n'existe pas dans la partie SELECT donc message d'erreur.

Essaye plutôt :

Code :

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

1
2
3
4
select Nom_Ville
from Villes
where Nb_Habitants>(SELECT avg(Nb_Habitants) from Villes)
order by Nom_Ville;

[od125]

oui ça marche bien, merci

[od125]

j'ai également créer une table Pays(Code_Pays, Nom_Pays) et je voudrais afficher le pays qui la max de nombre d'habitants j'ai esséyer plusieurs requete mais ça n'a pas marché, j'ai esseyé avec max :

Code :

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

1
2
3
4
select Nom_Pays 
from Pays,Villes
where (select max(Villes.Nb_Habitants) from Villes )
order by Nom_Pays;

erreur : expression absente
et j'ai esséyé avec join :

Code :

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

1
2
3
select Nom_Pays 
from Pays join Villes on (select max (Nb_Habitants))
order by Nom_Pays;

[Ikebukuro]

Houlalalala, pas bon, il faudrait que tu relises comment faire des jointures selon la syntaxe ANSI SQL 92 car là... la jointure doit se faire sur un nom de colonne, pas sur une expression.

Code :

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

from Pays join Villes on (select max (Nb_Habitants))

[od125]

j'ai essayé cette requête

Code :

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

1
2
3
4
5
6
select Nom_Pays 
from Pays
join Villes on(Villes.Code_Pays=Pays.Code_Pays)
group by Nom_Pays
having max(Nb_Habitants) in (select max(Nb_Habitants) from Villes)
;

mais le résultat n'est pas exact , alors est-ce que je peut exécuter cette requête sans jointure?

[Scriuiw]

Tu peux essayer avec une clause

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
select Nom_Pays, Nb_Habitants 
from Pays
  join Villes 
    on Villes.Code_Pays=Pays.Code_Pays
where Nb_Habitants =
  (select max(Nb_Habitants) 
  from Villes
  where Pays.Code_Pays = Code_Pays
  )
;

[od125]

j'ai eu le même résultat qu'avec ma requête , j'ai obtenue plusieurs pays alors que moi je veux juste le pays qui a le maximum d'habitants

[tbc92]

Etape 1 , on fait une requête qui donne le nombre d'habitants de chaque pays.
Et on vérifie que cette requête fonctionne.

Code :

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

1
2
3
4
select p.code_pays , p.nom_pays , sum ( v.nb_habitants) as nb_habitants_pays
from pays p, villes v 
where v.code_pays = p.code_pays
group by p.code_pays, p.nom_pays

Cette requête est bonne ?

Si oui, on passe à l'étape 2 : afficher uniquement le pays qui a le plus d'habitants.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
With population_pays as (
select p.code_pays , p.nom_pays , sum ( v.nb_habitants) as nb_habitants_pays
from pays p, villes v 
where v.code_pays = p.code_pays
group by p.code_pays, p.nom_pays
)
select * from population_pays 
order by nb_habitants_pays desc 
fetch first 1 rows only

[od125]

la 1ere requête marche très bien, mais en exécutant la 2eme requête il y a erreur : la commande sql ne se termine pas correctement

[Scriuiw]

j'ai eu le même résultat qu'avec ma requête , j'ai obtenue plusieurs pays alors que moi je veux juste le pays qui a le maximum d'habitants

Dans ce cas il suffit de supprimer la jointure sur le pays dans la sous-requête MAX (Attention, si deux pays ont le même nombre max d'habitants alors la requête retournera les deux pays concernés)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
select Nom_Pays, Nb_Habitants 
from Pays
  join Villes 
    on Villes.Code_Pays=Pays.Code_Pays
where Nb_Habitants =
  (select max(Nb_Habitants) 
  from Villes
  where Pays.Code_Pays = Code_Pays
  )
;

[tbc92]

La syntaxe with xxx as ( ...) select ... from xxx est acceptée depuis la version 9.2 d'Oracle.
La syntaxe FETCH FIRST xx ROWS Only, je crois qu'elle est acceptée depuis la version 10 d'Oracle.

Donc 2 questions :
- Quelle version d'Oracle as-tu ?
- Quel est le mesage d'erreur précis. A priori, Oracle te dis quelle ligne de la requête fait planter.

Et pour débugger, c'est toujours utile d'avancer pas à pas. Que se passe-t-il si tu fais :

Code :

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

1
2
3
4
5
6
7
8
With population_pays as (
select p.code_pays , p.nom_pays , sum ( v.nb_habitants) as nb_habitants_pays
from pays p, villes v 
where v.code_pays = p.code_pays
group by p.code_pays, p.nom_pays
)
select * from population_pays 
order by nb_habitants_pays desc

[McM]

Tbc, il me semble que la syntaxe FETCH ROW existe seulement depuis la 12.1
https://oracle-base.com/articles/12c...-queries-12cr1

[tbc92]

Dans ce cas il suffit de supprimer la jointure sur le pays dans la sous-requête MAX (Attention, si deux pays ont le même nombre max d'habitants alors la requête retournera les deux pays concernés)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
select Nom_Pays, Nb_Habitants 
from Pays
  join Villes 
    on Villes.Code_Pays=Pays.Code_Pays
where Nb_Habitants =
  (select max(Nb_Habitants) 
  from Villes
  where Pays.Code_Pays = Code_Pays
  )
;

Cette requête ne peut pas marcher.
Si on se limite aux 4 premières lignes de la requête, on affiche le nom du Pays ( France, Allemagne, Algérie par exemple), et pour chaque pays, on affiche plein de lignes. Le nombre qui est affiché dans la colonne 2, ce n'est pas la population du pays, mais la population de chaque ville ( donc on affiche 10000 lignes si il y a 10000 villes).
La fin de la requête va limiter le nombre de lignes.
Mais la population dans la 2ème colonne, ce ne sera toujours pas la population du pays, mais la population d'une ville.

[tbc92]

Si la syntaxe FETCH FIRST XX ROWS ONLY est refusée, on va faire :

Code :

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

1
2
3
4
5
6
7
8
9
 
select * from 
  ( select p.code_pays , p.nom_pays , sum ( v.nb_habitants) as nb_habitants_pays
    from pays p, villes v 
    where v.code_pays = p.code_pays
    group by p.code_pays, p.nom_pays
    order by  sum (v.nb_habitants) desc 
  )
where rownum <= 1

[Scriuiw]

Cette requête ne peut pas marcher.
Si on se limite aux 4 premières lignes de la requête, on affiche le nom du Pays ( France, Allemagne, Algérie par exemple), et pour chaque pays, on affiche plein de lignes. Le nombre qui est affiché dans la colonne 2, ce n'est pas la population du pays, mais la population de chaque ville ( donc on affiche 10000 lignes si il y a 10000 villes).
La fin de la requête va limiter le nombre de lignes.
Mais la population dans la 2ème colonne, ce ne sera toujours pas la population du pays, mais la population d'une ville.

Ah ! Pourtant le résultat me semble très correct :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
with data as
(select 'FR' AS Nom_Pays, 'Paris' AS Ville, 10000 AS Nb_Habitants from dual
union
select 'FR' AS Nom_Pays, 'Lyon' AS Ville, 1000 AS Nb_Habitants from dual
union
select 'FR' AS Nom_Pays, 'Marseille' AS Ville, 100 AS Nb_Habitants from dual
union
select 'ES' AS Nom_Pays, 'Madrid' AS Ville, 10 AS Nb_Habitants from dual
union
select 'ES' AS Nom_Pays, 'Barcelone' AS Ville, 2000 AS Nb_Habitants from dual
union
select 'GB' AS Nom_Pays, 'Londre' AS Ville, 15000 AS Nb_Habitants from dual
)
select Nom_Pays, Nb_Habitants 
from data
where Nb_Habitants =
  (select max(Nb_Habitants) 
  from data
  --where V.Code_Pays = Code_Pays
  )
;

Résultat

Code :

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

1
2
3
4
 
NO NB_HABITANTS
-- ------------
GB        15000

A moins, comme le montre votre dernière exemple, de faire la somme des habitants du pays, dans ce cas j'ai été "fourvoyé" par les exemples de od125 qui semblaient démontrer une sélection du pays avec la ville la plus peuplée :

Code :

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

1
2
3
4
5
6
select Nom_Pays 
from Pays
join Villes on(Villes.Code_Pays=Pays.Code_Pays)
group by Nom_Pays
having max(Nb_Habitants) in (select max(Nb_Habitants) from Villes)
;

[tatayo]

Bonjour,
Il suffit de modifier légèrement le jeu de test pour voir que le résultat est faux:

Code sql :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
with data as
(select 'FR' AS Nom_Pays, 'Paris' AS Ville, 10000 AS Nb_Habitants from dual
union
select 'FR' AS Nom_Pays, 'Lyon' AS Ville, 10000 AS Nb_Habitants from dual
union
select 'FR' AS Nom_Pays, 'Marseille' AS Ville, 10000 AS Nb_Habitants from dual
union
select 'ES' AS Nom_Pays, 'Madrid' AS Ville, 10 AS Nb_Habitants from dual
union
select 'ES' AS Nom_Pays, 'Barcelone' AS Ville, 2000 AS Nb_Habitants from dual
union
select 'GB' AS Nom_Pays, 'Londre' AS Ville, 15000 AS Nb_Habitants from dual
)
select Nom_Pays, Nb_Habitants 
from data
where Nb_Habitants =
  (select max(Nb_Habitants) 
  from data
  --where V.Code_Pays = Code_Pays
  )
;

Ici le résultat de la requête ne change pas (GB,15000), alors que la bonne réponse est FR,30000.

Tatayo.

[od125]

la version d'oracle que j'ai est 11g
la requête suivante a très bien marcher pour moi

Code :

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

1
2
3
4
5
6
7
8
select * from 
  ( select p.code_pays , p.nom_pays , sum ( v.nb_habitants) as nb_habitants_pays
    from pays p, villes v 
    where v.code_pays = p.code_pays
    group by p.code_pays, p.nom_pays
    order by  sum (v.nb_habitants) desc 
  )
where rownum <= 1

merci

[tatayo]

Oui, mais non.
Dans le cas (peu probable, je l'avoue) d'une égalité entre les deux pays les plus peuplés, la requête n'en renvoie qu'un.
Ici il faut en premier faire la somme des habitants par pays, puis chercher les pays dont la population est le max de la première requête.

Tatayo.