Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Windows Windows Serveur SQL Serveur question pur SQL

question pur SQL

11 réponses
Avatar
Ch.
Bonjour,

j'ai une table qui contient 2 champs
ID_UTIL, ID_FILM

cette table contient 100% des films de chaque utilisateur !

comment sans faire une boucle par utilisateur récupérer seulement les 2/3
des films de chaque utilisateur ?

Merci par avance !

ps: Sous SQL2000
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2
Avatar
Patrice
Le plus "visuel" serait par exemple de créer deux pseudo-colonnes :
- la première est une sous-requête qui compte le nombre de films pour le
même utilisateur
- la deuxième est une sous-requête qui compte le nombre de films pour le
même utilisateur et dont la clé est inférieur ou égale (pour numéroter les
films)

Reste à mettre le critère dans la clause where. Eventuellement faire un JOIN
avec un group by pour le comptage pour présenter les choses peut-être plus
élégamment/efficacement.

Cela donnerait SELECT *,(SELECT * FROM etc...) AS Films,(SELECT * FROM
etc...) AS Numéro FROM ... WHERE Numéro<=Films*2/3

Cela ressemble à un devoir ?

--
Patrice

"Ch." a écrit dans le message de news:
OtYu%
Bonjour,

j'ai une table qui contient 2 champs
ID_UTIL, ID_FILM

cette table contient 100% des films de chaque utilisateur !

comment sans faire une boucle par utilisateur récupérer seulement les 2/3
des films de chaque utilisateur ?

Merci par avance !

ps: Sous SQL2000




Avatar
Roger
En 2 temps :

1.Tu comptes le nombre d'enregistrements du dataset et tu en récupère les 2
tiers.
2.Tu utilises la clause SQL nommée TOP (Attention : cette clause n'est pas
supportée par tous les SGBD) :
Cette clause ne récupère que les n premiers enregistrements (ou n
représente la valeur spécifiée dans la clause).

Exemple :
Nb = (2/3) * Nombre Total d'enregistrement.
Requête = SELECT TOP Nb....(Attention la syntaxe varie en fonction du SGBD)



"Ch." a écrit dans le message de
news:OtYu%
Bonjour,

j'ai une table qui contient 2 champs
ID_UTIL, ID_FILM

cette table contient 100% des films de chaque utilisateur !

comment sans faire une boucle par utilisateur récupérer seulement les 2/3
des films de chaque utilisateur ?

Merci par avance !

ps: Sous SQL2000




Avatar
Synopsis
SELECT A.*
FROM TBL AS A
WHERE A.ID_FILM IN
(
SELECT TOP 75 PERCENT B.ID_FILM
FROM TBL AS B
WHERE A.ID_UTIL = B.ID_UTIL
)


OUI OUI...
CELA RESSEMBLE A UN DEVOIR



"Patrice" a écrit dans le message de
news:%
Le plus "visuel" serait par exemple de créer deux pseudo-colonnes :
- la première est une sous-requête qui compte le nombre de films pour le
même utilisateur
- la deuxième est une sous-requête qui compte le nombre de films pour le
même utilisateur et dont la clé est inférieur ou égale (pour numéroter les
films)

Reste à mettre le critère dans la clause where. Eventuellement faire un


JOIN
avec un group by pour le comptage pour présenter les choses peut-être plus
élégamment/efficacement.

Cela donnerait SELECT *,(SELECT * FROM etc...) AS Films,(SELECT * FROM
etc...) AS Numéro FROM ... WHERE Numéro<=Films*2/3

Cela ressemble à un devoir ?

--
Patrice

"Ch." a écrit dans le message de news:
OtYu%
> Bonjour,
>
> j'ai une table qui contient 2 champs
> ID_UTIL, ID_FILM
>
> cette table contient 100% des films de chaque utilisateur !
>
> comment sans faire une boucle par utilisateur récupérer seulement les


2/3
> des films de chaque utilisateur ?
>
> Merci par avance !
>
> ps: Sous SQL2000
>
>




Avatar
Christophe
patrice ta solution renvoi tout les enregistrements de la table A
au lieu de filtrer sur les 2/3

????

"Synopsis" wrote:


SELECT A.*
FROM TBL AS A
WHERE A.ID_FILM IN
(
SELECT TOP 75 PERCENT B.ID_FILM
FROM TBL AS B
WHERE A.ID_UTIL = B.ID_UTIL
)


OUI OUI...
CELA RESSEMBLE A UN DEVOIR



"Patrice" a écrit dans le message de
news:%
> Le plus "visuel" serait par exemple de créer deux pseudo-colonnes :
> - la première est une sous-requête qui compte le nombre de films pour le
> même utilisateur
> - la deuxième est une sous-requête qui compte le nombre de films pour le
> même utilisateur et dont la clé est inférieur ou égale (pour numéroter les
> films)
>
> Reste à mettre le critère dans la clause where. Eventuellement faire un
JOIN
> avec un group by pour le comptage pour présenter les choses peut-être plus
> élégamment/efficacement.
>
> Cela donnerait SELECT *,(SELECT * FROM etc...) AS Films,(SELECT * FROM
> etc...) AS Numéro FROM ... WHERE Numéro<=Films*2/3
>
> Cela ressemble à un devoir ?
>
> --
> Patrice
>
> "Ch." a écrit dans le message de news:
> OtYu%
> > Bonjour,
> >
> > j'ai une table qui contient 2 champs
> > ID_UTIL, ID_FILM
> >
> > cette table contient 100% des films de chaque utilisateur !
> >
> > comment sans faire une boucle par utilisateur récupérer seulement les
2/3
> > des films de chaque utilisateur ?
> >
> > Merci par avance !
> >
> > ps: Sous SQL2000
> >
> >
>
>





Avatar
Christophe
voila la solution que j'ai adopté et qui marche mais c'est pour ma curiosité
intellectuelle. car je pense que l'ont doit pouvoir faire mieux !

tempouser contient uniquement les users pour la boucle
tempo contient 100% des user et de leurs films !


declare @USER varchar(25)
while (select top 1 userid from #tempousers) is not null
begin
--recup un utilisateur dispo
select top 1 @user = userid from #tempousers

insert into #tempocrit (reffilm, userid, note)
select top 66 percent reffilm, userid, note
--pour prendre 66% de films en aléatoire
from #tempo
where userid = @user
order by newid()
-- permet un asser bon alétoire
-- attention chaque relance change l'aleatoire !

--efface le user apres son utilisation sinon boucle sans fin
delete from #tempousers where userid = @user
end
Avatar
Patrice
Et les valeurs des colonnes sont bonnes ? Sinon la solution avec le TOP 75
PERCENT me semble effectivement plus directe si tu n'as pas besoin
d'expliquer un cheminement pas à pas...

--

"Christophe" a écrit dans le message
de news:
patrice ta solution renvoi tout les enregistrements de la table A
au lieu de filtrer sur les 2/3

????

"Synopsis" wrote:


SELECT A.*
FROM TBL AS A
WHERE A.ID_FILM IN
(
SELECT TOP 75 PERCENT B.ID_FILM
FROM TBL AS B
WHERE A.ID_UTIL = B.ID_UTIL
)


OUI OUI...
CELA RESSEMBLE A UN DEVOIR



"Patrice" a écrit dans le message de
news:%
> Le plus "visuel" serait par exemple de créer deux pseudo-colonnes :
> - la première est une sous-requête qui compte le nombre de films pour
> le
> même utilisateur
> - la deuxième est une sous-requête qui compte le nombre de films pour
> le
> même utilisateur et dont la clé est inférieur ou égale (pour numéroter
> les
> films)
>
> Reste à mettre le critère dans la clause where. Eventuellement faire un
JOIN
> avec un group by pour le comptage pour présenter les choses peut-être
> plus
> élégamment/efficacement.
>
> Cela donnerait SELECT *,(SELECT * FROM etc...) AS Films,(SELECT * FROM
> etc...) AS Numéro FROM ... WHERE Numéro<=Films*2/3
>
> Cela ressemble à un devoir ?
>
> --
> Patrice
>
> "Ch." a écrit dans le message de news:
> OtYu%
> > Bonjour,
> >
> > j'ai une table qui contient 2 champs
> > ID_UTIL, ID_FILM
> >
> > cette table contient 100% des films de chaque utilisateur !
> >
> > comment sans faire une boucle par utilisateur récupérer seulement les
2/3
> > des films de chaque utilisateur ?
> >
> > Merci par avance !
> >
> > ps: Sous SQL2000
> >
> >
>
>







Avatar
SQLpro [MVP]
Bonjour,

CREATE TABLE T_USER_FILM
(ID_UTIL INT,
ID_FILM INT)


INSERT INTO T_USER_FILM VALUES (1, 100)
INSERT INTO T_USER_FILM VALUES (1, 101)
INSERT INTO T_USER_FILM VALUES (1, 102)
INSERT INTO T_USER_FILM VALUES (2, 201)
INSERT INTO T_USER_FILM VALUES (2, 202)
INSERT INTO T_USER_FILM VALUES (2, 203)
INSERT INTO T_USER_FILM VALUES (2, 204)
INSERT INTO T_USER_FILM VALUES (2, 205)
INSERT INTO T_USER_FILM VALUES (2, 206)
INSERT INTO T_USER_FILM VALUES (3, 301)
INSERT INTO T_USER_FILM VALUES (4, 401)
INSERT INTO T_USER_FILM VALUES (4, 402)

-- solution :

SELECT T1.ID_UTIL, T1.ID_FILM
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3


Il serait temps de suivre quelques uns de mes cours....

Sur le net (SQLpro) par mes bouquins ou en formation pro...

A +


Ch. a écrit :
Bonjour,

j'ai une table qui contient 2 champs
ID_UTIL, ID_FILM

cette table contient 100% des films de chaque utilisateur !

comment sans faire une boucle par utilisateur récupérer seulement les 2/3
des films de chaque utilisateur ?

Merci par avance !

ps: Sous SQL2000






--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Avatar
Christophe
Merci à
toi j'avoue ne pas bien comprendre la requete mais elle fonctionne
parfaitement !

ce que je ne comprends pas bien c'est la jointure
AND T1.ID_FILM <= T2.ID_FILM
pourquoi T1.id_film doit etre inferieur à T2.id_film ?
quelle est cette subtilité ?



"SQLpro [MVP]" a écrit dans le message de
news:
Bonjour,

CREATE TABLE T_USER_FILM
(ID_UTIL INT,
ID_FILM INT)


INSERT INTO T_USER_FILM VALUES (1, 100)
INSERT INTO T_USER_FILM VALUES (1, 101)
INSERT INTO T_USER_FILM VALUES (1, 102)
INSERT INTO T_USER_FILM VALUES (2, 201)
INSERT INTO T_USER_FILM VALUES (2, 202)
INSERT INTO T_USER_FILM VALUES (2, 203)
INSERT INTO T_USER_FILM VALUES (2, 204)
INSERT INTO T_USER_FILM VALUES (2, 205)
INSERT INTO T_USER_FILM VALUES (2, 206)
INSERT INTO T_USER_FILM VALUES (3, 301)
INSERT INTO T_USER_FILM VALUES (4, 401)
INSERT INTO T_USER_FILM VALUES (4, 402)

-- solution :

SELECT T1.ID_UTIL, T1.ID_FILM
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3


Il serait temps de suivre quelques uns de mes cours....

Sur le net (SQLpro) par mes bouquins ou en formation pro...

A +


Ch. a écrit :
> Bonjour,
>
> j'ai une table qui contient 2 champs
> ID_UTIL, ID_FILM
>
> cette table contient 100% des films de chaque utilisateur !
>
> comment sans faire une boucle par utilisateur récupérer seulement les


2/3
> des films de chaque utilisateur ?
>
> Merci par avance !
>
> ps: Sous SQL2000
>
>


--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************


Avatar
SQLpro [MVP]
-- 1) on classe les occurrences

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT
----------- ----------- -----------
1 102 1
1 101 2
1 100 3

2 206 1
2 205 2
2 204 3
2 203 4
2 202 5
2 201 6

3 301 1

4 402 1
4 401 2


-- 2) on calcule le nombre total

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL
----------- ----------- ----------- ------------
1 102 1 3
1 101 2 3
1 100 3 3

2 206 1 6
2 205 2 6
2 204 3 6
2 203 4 6
2 202 5 6
2 201 6 6

3 301 1 1

4 402 1 2
4 401 2 2


-- 3) on calcule des 2/3 du total

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3 AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL
----------- ----------- ----------- ------------
1 102 1 2
1 101 2 2
1 100 3 2

2 206 1 4
2 205 2 4
2 204 3 4
2 203 4 4
2 202 5 4
2 201 6 4

3 301 1 0

4 402 1 1
4 401 2 1


-- 4) on écrème....

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3 AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3
ORDER BY 1, 3


Si tu veut un calcul plus précis, transtype en flottant :

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
ROUND(CAST((SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS FLOAT)
* 2.0 / 3.0, 0) AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM)
<= ROUND(CAST((SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS FLOAT) * 2.0 / 3.0, 0)
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL

----------- ----------- ----------- -------------
1 102 1 2.0
1 101 2 2.0
2 206 1 4.0
2 205 2 4.0
2 204 3 4.0
2 203 4 4.0
3 301 1 1.0
4 402 1 1.0

A +

SQLpro [MVP] a écrit :
Bonjour,

CREATE TABLE T_USER_FILM
(ID_UTIL INT,
ID_FILM INT)


INSERT INTO T_USER_FILM VALUES (1, 100)
INSERT INTO T_USER_FILM VALUES (1, 101)
INSERT INTO T_USER_FILM VALUES (1, 102)
INSERT INTO T_USER_FILM VALUES (2, 201)
INSERT INTO T_USER_FILM VALUES (2, 202)
INSERT INTO T_USER_FILM VALUES (2, 203)
INSERT INTO T_USER_FILM VALUES (2, 204)
INSERT INTO T_USER_FILM VALUES (2, 205)
INSERT INTO T_USER_FILM VALUES (2, 206)
INSERT INTO T_USER_FILM VALUES (3, 301)
INSERT INTO T_USER_FILM VALUES (4, 401)
INSERT INTO T_USER_FILM VALUES (4, 402)

-- solution :

SELECT T1.ID_UTIL, T1.ID_FILM
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3


Il serait temps de suivre quelques uns de mes cours....

Sur le net (SQLpro) par mes bouquins ou en formation pro...

A +


Ch. a écrit :
Bonjour,

j'ai une table qui contient 2 champs
ID_UTIL, ID_FILM

cette table contient 100% des films de chaque utilisateur !

comment sans faire une boucle par utilisateur récupérer seulement les
2/3 des films de chaque utilisateur ?

Merci par avance !

ps: Sous SQL2000










--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************
Avatar
Christophe
ok j'ai compris et le tout en une requete alors la je dis bravo t'es un kind
y'a pas à dire !
lequel de tes bouquin j'ai le plus besoin pour pouvoir ecrire des requetes
comme toi ?

Merci encore et surtout pour les explications !





"SQLpro [MVP]" a écrit dans le message de
news:O%

-- 1) on classe les occurrences

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT
----------- ----------- -----------
1 102 1
1 101 2
1 100 3

2 206 1
2 205 2
2 204 3
2 203 4
2 202 5
2 201 6

3 301 1

4 402 1
4 401 2


-- 2) on calcule le nombre total

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL
----------- ----------- ----------- ------------
1 102 1 3
1 101 2 3
1 100 3 3

2 206 1 6
2 205 2 6
2 204 3 6
2 203 4 6
2 202 5 6
2 201 6 6

3 301 1 1

4 402 1 2
4 401 2 2


-- 3) on calcule des 2/3 du total

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3 AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL
----------- ----------- ----------- ------------
1 102 1 2
1 101 2 2
1 100 3 2

2 206 1 4
2 205 2 4
2 204 3 4
2 203 4 4
2 202 5 4
2 201 6 4

3 301 1 0

4 402 1 1
4 401 2 1


-- 4) on écrème....

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
(SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3 AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3
ORDER BY 1, 3


Si tu veut un calcul plus précis, transtype en flottant :

SELECT T1.ID_UTIL, T1.ID_FILM,
COUNT(ALL T2.ID_FILM) AS CLASSEMENT,
ROUND(CAST((SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS FLOAT)
* 2.0 / 3.0, 0) AS NOMBRE_TOTAL
FROM T_USER_FILM AS T1
INNER JOIN T_USER_FILM AS T2
ON T1.ID_UTIL = T2.ID_UTIL
AND T1.ID_FILM <= T2.ID_FILM
GROUP BY T1.ID_UTIL, T1.ID_FILM
HAVING COUNT(ALL T2.ID_FILM)
<= ROUND(CAST((SELECT COUNT(*)
FROM T_USER_FILM
WHERE ID_UTIL = T1.ID_UTIL) AS FLOAT) * 2.0 / 3.0, 0)
ORDER BY 1, 3

ID_UTIL ID_FILM CLASSEMENT NOMBRE_TOTAL

----------- ----------- ----------- -------------
1 102 1 2.0
1 101 2 2.0
2 206 1 4.0
2 205 2 4.0
2 204 3 4.0
2 203 4 4.0
3 301 1 1.0
4 402 1 1.0

A +

SQLpro [MVP] a écrit :
> Bonjour,
>
> CREATE TABLE T_USER_FILM
> (ID_UTIL INT,
> ID_FILM INT)
>
>
> INSERT INTO T_USER_FILM VALUES (1, 100)
> INSERT INTO T_USER_FILM VALUES (1, 101)
> INSERT INTO T_USER_FILM VALUES (1, 102)
> INSERT INTO T_USER_FILM VALUES (2, 201)
> INSERT INTO T_USER_FILM VALUES (2, 202)
> INSERT INTO T_USER_FILM VALUES (2, 203)
> INSERT INTO T_USER_FILM VALUES (2, 204)
> INSERT INTO T_USER_FILM VALUES (2, 205)
> INSERT INTO T_USER_FILM VALUES (2, 206)
> INSERT INTO T_USER_FILM VALUES (3, 301)
> INSERT INTO T_USER_FILM VALUES (4, 401)
> INSERT INTO T_USER_FILM VALUES (4, 402)
>
> -- solution :
>
> SELECT T1.ID_UTIL, T1.ID_FILM
> FROM T_USER_FILM AS T1
> INNER JOIN T_USER_FILM AS T2
> ON T1.ID_UTIL = T2.ID_UTIL
> AND T1.ID_FILM <= T2.ID_FILM
> GROUP BY T1.ID_UTIL, T1.ID_FILM
> HAVING COUNT(ALL T2.ID_FILM) <= (SELECT COUNT(*)
> FROM T_USER_FILM
> WHERE ID_UTIL = T1.ID_UTIL) * 2 / 3
>
>
> Il serait temps de suivre quelques uns de mes cours....
>
> Sur le net (SQLpro) par mes bouquins ou en formation pro...
>
> A +
>
>
> Ch. a écrit :
>> Bonjour,
>>
>> j'ai une table qui contient 2 champs
>> ID_UTIL, ID_FILM
>>
>> cette table contient 100% des films de chaque utilisateur !
>>
>> comment sans faire une boucle par utilisateur récupérer seulement les
>> 2/3 des films de chaque utilisateur ?
>>
>> Merci par avance !
>>
>> ps: Sous SQL2000
>>
>>
>
>


--
Frédéric BROUARD, MVP SQL Server, expert bases de données et langage SQL
Le site sur le langage SQL et les SGBDR : http://sqlpro.developpez.com
Audit, conseil, expertise, formation, modélisation, tuning, optimisation
********************* http://www.datasapiens.com ***********************


1 2