add maths's project and system

2A/BDD/tp/s1/requetesTP4-5-6.sql

@@ -1,336 +1,409 @@
-\! clear
+-- \! clear
--- -- ? 1 - Écrire une fonction qui pour un match donné calcule le nombre de rebonds 
+-- -- -- ? 1 - Écrire une fonction qui pour un match donné calcule le nombre de rebonds 
--- -- ? pris par les joueurs qui n’ont pas débuté la rencontre. Proposez deux versions, 
+-- -- -- ? pris par les joueurs qui n’ont pas débuté la rencontre. Proposez deux versions, 
--- -- ? une utilisant les fonctions d’agrégation et une autre utilisant un curseur mais aucune fonction d’agrégation.
+-- -- -- ? une utilisant les fonctions d’agrégation et une autre utilisant un curseur mais aucune fonction d’agrégation.
+
+-- -- CREATE OR REPLACE FUNCTION calcul_rebonds(match Game.id%TYPE) RETURNS integer AS $$
+-- -- DECLARE
+-- --     sumRebounds integer;
+-- -- BEGIN
+-- --     SELECT sum(gd.rebounds) INTO sumRebounds
+-- --     FROM GameDetail gd, Game g
+-- --     WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NULL;
+
+-- --     RETURN sumRebounds;
+-- -- END;
+-- -- $$ LANGUAGE plpgsql;
+
+-- -- SELECT calcul_rebonds('22100979');
+
+-- -- -- CREATE FUNCTION
+-- -- --  calcul_rebonds 
+-- -- -- ----------------
+-- -- --              32
+-- -- -- (1 row)
+
+-- -- CREATE OR REPLACE FUNCTION calcul_rebonds_curs(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
+-- -- DECLARE
+-- --     sumRebounds GameDetail.rebounds%TYPE := 0;
+-- --     rbs GameDetail.rebounds%TYPE := 0;
+-- --     curs cursor FOR SELECT rebounds
+-- --                     FROM GameDetail 
+-- --                     WHERE idGame = match AND startPosition is NULL AND rebounds is NOT NULL;
+-- -- BEGIN
+-- --     OPEN curs;
+-- --     FETCH curs INTO rbs;
+
+-- --     WHILE FOUND LOOP
+-- --         sumRebounds = sumRebounds + rbs;
+-- --         FETCH curs INTO rbs;
+-- --     END LOOP;
+    
+-- --     CLOSE curs;
+
+-- --     RETURN sumRebounds;
+-- -- END;
+-- -- $$ LANGUAGE plpgsql;
+
+-- -- SELECT calcul_rebonds_curs('22100979');
+
+-- -- -- CREATE FUNCTION
+-- -- --  calcul_rebonds_curs 
+-- -- -- ---------------------
+-- -- --                   32
+-- -- -- (1 row)
 
--- CREATE OR REPLACE FUNCTION calcul_rebonds(match Game.id%TYPE) RETURNS integer AS $$
--- DECLARE
---     sumRebounds integer;
--- BEGIN
---     SELECT sum(gd.rebounds) INTO sumRebounds
---     FROM GameDetail gd, Game g
---     WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NULL;
 
---     RETURN sumRebounds;
--- END;
--- $$ LANGUAGE plpgsql;
 
--- SELECT calcul_rebonds('22100979');
+-- -- -- ? 2 - Vérifier que vos deux versions retournent les mêmes résultats en affichant le nombre total de rebonds 
+-- -- -- ? pris par les joueurs n’ayant pas débuté la rencontre pour tous les matchs ayant eu lieu le 12 mars 2022.
 
--- -- CREATE FUNCTION
+-- -- SELECT calcul_rebonds(id)
--- --  calcul_rebonds 
+-- -- FROM Game
--- -- ----------------
+-- -- WHERE dateGame = '2022-03-12';
--- --              32
--- -- (1 row)
 
--- CREATE OR REPLACE FUNCTION calcul_rebonds_curs(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
+-- -- --  calcul_rebonds 
--- DECLARE
+-- -- -- ----------------
---     sumRebounds GameDetail.rebounds%TYPE := 0;
+-- -- --              39
---     rbs GameDetail.rebounds%TYPE := 0;
+-- -- --              20
---     curs cursor FOR SELECT rebounds
+-- -- --              43
---                     FROM GameDetail 
+-- -- --              40
---                     WHERE idGame = match AND startPosition is NULL AND rebounds is NOT NULL;
+-- -- --              41
--- BEGIN
+-- -- --              25
---     OPEN curs;
+-- -- --              24
---     FETCH curs INTO rbs;
+-- -- -- (7 rows)
+
+-- -- SELECT calcul_rebonds_curs(id)
+-- -- FROM Game
+-- -- WHERE dateGame = '2022-03-12';
+
+-- -- --  calcul_rebonds_curs 
+-- -- -- ---------------------
+-- -- --                   39
+-- -- --                   20
+-- -- --                   43
+-- -- --                   40
+-- -- --                   41
+-- -- --                   25
+-- -- --                   24
+-- -- -- (7 rows)
+
+
+-- -- -- ? 3 - Écrire une fonction qui calcule la même chose mais pour les joueurs ayant débuté la rencontre, 
+-- -- -- ? autrement dit qui calcule, pour un match donné, le nombre de rebonds pris par les joueurs ayant débuté la rencontre.
+
+-- -- CREATE OR REPLACE FUNCTION calcul_rebonds_t(match Game.id%TYPE) RETURNS integer AS $$
+-- -- DECLARE
+-- --     sumRebounds integer;
+-- -- BEGIN
+-- --     SELECT sum(gd.rebounds) INTO sumRebounds
+-- --     FROM GameDetail gd, Game g
+-- --     WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NOT NULL;
 
---     WHILE FOUND LOOP
+-- --     IF sumRebounds is NULL THEN 
---         sumRebounds = sumRebounds + rbs;
+-- --         RETURN 0;
---         FETCH curs INTO rbs;
+-- --     END IF;
---     END LOOP;
 
---     CLOSE curs;
+-- --     RETURN sumRebounds;
+-- -- END;
+-- -- $$ LANGUAGE plpgsql;
 
---     RETURN sumRebounds;
+-- -- SELECT calcul_rebonds_t('22100979');
--- END;
--- $$ LANGUAGE plpgsql;
 
--- SELECT calcul_rebonds_curs('22100979');
+-- -- -- CREATE FUNCTION
+-- -- --  calcul_rebonds_t 
+-- -- -- ------------------
+-- -- --                57
+-- -- -- (1 row)
 
--- -- CREATE FUNCTION
+-- -- CREATE OR REPLACE FUNCTION calcul_rebonds_curs_t(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
--- --  calcul_rebonds_curs 
+-- -- DECLARE
--- -- ---------------------
+-- --     sumRebounds GameDetail.rebounds%TYPE := 0;
--- --                   32
+-- --     rbs GameDetail.rebounds%TYPE := 0;
--- -- (1 row)
+-- --     curs cursor FOR SELECT rebounds
+-- --                     FROM GameDetail 
+-- --                     WHERE idGame = match AND startPosition is NOT NULL AND rebounds is NOT NULL;
+-- -- BEGIN
+-- --     OPEN curs;
+-- --     FETCH curs INTO rbs;
 
+-- --     WHILE FOUND LOOP
+-- --         sumRebounds = sumRebounds + rbs;
+-- --         FETCH curs INTO rbs;
+-- --     END LOOP;
     
+-- --     CLOSE curs;
 
--- -- ? 2 - Vérifier que vos deux versions retournent les mêmes résultats en affichant le nombre total de rebonds 
+-- --     RETURN sumRebounds;
--- -- ? pris par les joueurs n’ayant pas débuté la rencontre pour tous les matchs ayant eu lieu le 12 mars 2022.
+-- -- END;
+-- -- $$ LANGUAGE plpgsql;
 
--- SELECT calcul_rebonds(id)
+-- -- SELECT calcul_rebonds_curs_t('22100979');
--- FROM Game
--- WHERE dateGame = '2022-03-12';
 
--- --  calcul_rebonds 
+-- -- -- CREATE FUNCTION
--- -- ----------------
+-- -- --  calcul_rebonds_curs_t 
--- --              39
+-- -- -- -----------------------
--- --              20
+-- -- --                     57
--- --              43
+-- -- -- (1 row)
--- --              40
--- --              41
--- --              25
--- --              24
--- -- (7 rows)
 
--- SELECT calcul_rebonds_curs(id)
+-- -- SELECT calcul_rebonds_t('10300004');
--- FROM Game
+-- -- SELECT calcul_rebonds_curs_t('10300004');
--- WHERE dateGame = '2022-03-12';
 
--- --  calcul_rebonds_curs 
--- -- ---------------------
--- --                   39
--- --                   20
--- --                   43
--- --                   40
--- --                   41
--- --                   25
--- --                   24
--- -- (7 rows)
 
+-- -- -- ? 4 - Trouver le match (abréviation des équipes et date) pendant lequel les joueurs 
+-- -- -- ? ayant débuté la rencontre ont réalisé le plus de rebonds.
 
--- -- ? 3 - Écrire une fonction qui calcule la même chose mais pour les joueurs ayant débuté la rencontre, 
+-- -- SELECT t1.abbreviation, t2.abbreviation, g.dateGame, calcul_rebonds_t(g.id)
--- -- ? autrement dit qui calcule, pour un match donné, le nombre de rebonds pris par les joueurs ayant débuté la rencontre.
+-- -- FROM Game g, Team t1, Team t2
+-- -- WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
+-- --                                                                                     FROM Game);
 
--- CREATE OR REPLACE FUNCTION calcul_rebonds_t(match Game.id%TYPE) RETURNS integer AS $$
+-- -- --  abbreviation | abbreviation |  dategame  | calcul_rebonds_t 
--- DECLARE
+-- -- -- --------------+--------------+------------+------------------
---     sumRebounds integer;
+-- -- --  POR          | DEN          | 2019-05-03 |              101
--- BEGIN
+-- -- -- (1 row)
---     SELECT sum(gd.rebounds) INTO sumRebounds
---     FROM GameDetail gd, Game g
---     WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NOT NULL;
 
---     IF sumRebounds is NULL THEN 
---         RETURN 0;
---     END IF;
 
---     RETURN sumRebounds;
+-- -- -- ? 5 - Y a t’il des matchs pour lesquels les données sur les rebonds sont incohérentes? 
--- END;
+-- -- -- ? Vérifier en comparant les valeurs obtenus grâce aux fonctions précédentes avec les valeurs contenues dans la table Game.
--- $$ LANGUAGE plpgsql;
 
--- SELECT calcul_rebonds_t('22100979');
+-- -- -- ! SELECT t1.abbreviation, t2.abbreviation, g.dateGame, (calcul_rebonds_t(g.id) + calcul_rebonds(g.id)) as fct, g.reboundsHome, g.reboundsAway
+-- -- -- ! FROM Game g, Team t1, Team t2
+-- -- -- ! WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
+-- -- -- !                                                                                   FROM Game);
 
--- -- CREATE FUNCTION
--- --  calcul_rebonds_t 
--- -- ------------------
--- --                57
--- -- (1 row)
 
--- CREATE OR REPLACE FUNCTION calcul_rebonds_curs_t(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
+-- -- -- ? 6 - Écrire une fonction qui pour un match et une équipe donnée calcule le total des points des joueurs de cet équipe pendant le match, 
--- DECLARE
+-- -- -- ? à partir des données contenues dans la table GameDetail.
---     sumRebounds GameDetail.rebounds%TYPE := 0;
---     rbs GameDetail.rebounds%TYPE := 0;
---     curs cursor FOR SELECT rebounds
---                     FROM GameDetail 
---                     WHERE idGame = match AND startPosition is NOT NULL AND rebounds is NOT NULL;
--- BEGIN
---     OPEN curs;
---     FETCH curs INTO rbs;
 
---     WHILE FOUND LOOP
+-- -- CREATE OR REPLACE FUNCTION PtsTotJoueur(match Game.id%TYPE, team Team.id%TYPE)
---         sumRebounds = sumRebounds + rbs;
+-- -- RETURNS integer as $$
---         FETCH curs INTO rbs;
+-- -- DECLARE total integer;
---     END LOOP;
+-- -- BEGIN 
+-- --     SELECT sum(points) INTO total
+-- --     FROM GameDetail
+-- --     WHERE idTeam = team AND idGame = match AND points IS NOT NULL;
     
---     CLOSE curs;
+-- --     IF total is NULL THEN 
+-- --         RETURN 0;
+-- --     END IF;
 
---     RETURN sumRebounds;
+-- --     RETURN total;
--- END;
+-- -- END;
--- $$ LANGUAGE plpgsql;
+-- -- $$ LANGUAGE plpgsql; 
-
--- SELECT calcul_rebonds_curs_t('22100979');
-
--- -- CREATE FUNCTION
--- --  calcul_rebonds_curs_t 
--- -- -----------------------
--- --                     57
--- -- (1 row)
-
--- SELECT calcul_rebonds_t('10300004');
--- SELECT calcul_rebonds_curs_t('10300004');
 
 
--- -- ? 4 - Trouver le match (abréviation des équipes et date) pendant lequel les joueurs 
+-- -- SELECT PtsTotJoueur('22101006','1610612741');
--- -- ? ayant débuté la rencontre ont réalisé le plus de rebonds.
 
--- SELECT t1.abbreviation, t2.abbreviation, g.dateGame, calcul_rebonds_t(g.id)
+-- -- -- ? 7 - Utiliser cette fonction pour vérifier si les valeurs ptsHome et ptsAway de la table Game sont correctes.
--- FROM Game g, Team t1, Team t2
--- WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
---                                                                                     FROM Game);
 
--- --  abbreviation | abbreviation |  dategame  | calcul_rebonds_t 
+-- -- SELECT g.id AS idGame, t.id AS idTeam, g.ptsHome, g.ptsAway, PtsTotJoueur(g.id, g.idHomeTeam) AS ptsHome1, PtsTotJoueur(g.id, g.idVisitorTeam) AS ptsAway2
--- -- --------------+--------------+------------+------------------
+-- -- FROM GAME g, Team t
--- --  POR          | DEN          | 2019-05-03 |              101
+-- -- WHERE g.idVisitorTeam = t.id;
--- -- (1 row)
 
 
--- -- ? 5 - Y a t’il des matchs pour lesquels les données sur les rebonds sont incohérentes? 
+-- -- -- ? 8 - Quelle table contient des données incorrectes/incomplètes ? Game ou GameDetail ? Vérifier grâce aux résultats officiels des matchs.
--- -- ? Vérifier en comparant les valeurs obtenus grâce aux fonctions précédentes avec les valeurs contenues dans la table Game.
 
--- -- ! SELECT t1.abbreviation, t2.abbreviation, g.dateGame, (calcul_rebonds_t(g.id) + calcul_rebonds(g.id)) as fct, g.reboundsHome, g.reboundsAway
--- -- ! FROM Game g, Team t1, Team t2
--- -- ! WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
--- -- !                                                                                   FROM Game);
 
+-- -- ? 9 - Ecrire une fonction isBestAtHome qui retourne un booléen indiquant si une équipe donnée a
+-- -- ? gagné au moins autant de matchs à domicile qu’à l’extérieur lors de la saison passée en paramètre.
 
--- -- ? 6 - Écrire une fonction qui pour un match et une équipe donnée calcule le total des points des joueurs de cet équipe pendant le match, 
--- -- ? à partir des données contenues dans la table GameDetail.
 
--- CREATE OR REPLACE FUNCTION PtsTotJoueur(match Game.id%TYPE, team Team.id%TYPE)
+-- CREATE OR REPLACE FUNCTION isBestAtHome(IdTeam Team.id%TYPE, GameSeason Game.season%TYPE) RETURNS numeric AS $$
--- RETURNS integer as $$
+-- DECLARE 
--- DECLARE total integer;
+--     home_wins integer;
+--     away_wins integer;
 -- BEGIN
---     SELECT sum(points) INTO total
+--   SELECT COUNT(*) INTO home_wins
---     FROM GameDetail
+--   FROM GAME g
---     WHERE idTeam = team AND idGame = match AND points IS NOT NULL;
+--   WHERE g.season = GameSeason AND g.idHomeTeam = IdTeam AND g.ptsHome > g.ptsAway;
 
---     IF total is NULL THEN 
+--   SELECT COUNT(*) INTO away_wins
+--   FROM GAME g
+--   WHERE g.season = GameSeason AND g.idVisitorTeam = IdTeam AND g.ptsAway > g.ptsHome;
+
+--     IF (home_wins >= away_wins) THEN
+--         RETURN 1;
+--     ELSE
 --         RETURN 0;
 --     END IF;
+-- END;
+-- $$ LANGUAGE plpgsql;
+
+-- -- ? 10 - Vérifier que l’équipe des Spurs a été meilleure à domicile qu’à l’extérieur pendant la saison 2021.
+
+-- SELECT isBestAtHome(id, '2021') AS best_at_home
+-- FROM Team
+-- WHERE abbreviation = 'SAS';
 
---     RETURN total;
+-- -- ? 11 - Ecrire une fonction bestAtHome qui retourne une table avec les équipes (ids, abbréviations, noms et villes) 
+-- -- ? qui ont gagné au moins autant de matchs à domicile qu’à l’extérieur lors de la saison passée en paramètre.
+
+-- CREATE OR REPLACE FUNCTION BestAtHome(GameSeason Game.season%TYPE) 
+-- RETURNS TABLE(id Team.id%TYPE, abbreviation Team.abbreviation%TYPE, nom Team.nickname%TYPE, ville Team.city%TYPE) AS $$
+-- BEGIN
+--     RETURN QUERY SELECT DISTINCT t.id, t.abbreviation, t.nickname, t.city
+--                     FROM Team t
+--                     WHERE isBestAtHome(t.id, GameSeason) = 1;
 -- END;
 -- $$ LANGUAGE plpgsql;
 
+-- -- ? 12 - Quelles équipes ont gagné au moins autant de matchs à domicile qu’à l’extérieur en 2021?
 
--- SELECT PtsTotJoueur('22101006','1610612741');
+-- SELECT BestAtHome(2021);
 
--- -- ? 7 - Utiliser cette fonction pour vérifier si les valeurs ptsHome et ptsAway de la table Game sont correctes.
+-- -- ? 13 - Ecrire une fonction qui retourne un booléen indiquant si une équipe donnée à gagner au moins autant de matchs à 
+-- -- ? domiciles qu’à l’extérieur pendant au moins n saisons consécutives, où n est un paramètre de la fonction.
+-- -- ? Cette fonction devra lever une exception personnalisée si n n’est pas une valeur possible.
 
--- SELECT g.id AS idGame, t.id AS idTeam, g.ptsHome, g.ptsAway, PtsTotJoueur(g.id, g.idHomeTeam) AS ptsHome1, PtsTotJoueur(g.id, g.idVisitorTeam) AS ptsAway2
+-- CREATE OR REPLACE FUNCTION isBestAtHomeDuring(nbSeason numeric) RETURNS numeric AS $$
+-- DECLARE 
+--     home_wins integer;
+--     away_wins integer;
+-- BEGIN
+--   SELECT COUNT(*) INTO home_wins
 --   FROM GAME g, Team t
--- WHERE g.idVisitorTeam = t.id;
+--   WHERE g.idHomeTeam = t.id AND isBestAtHome(t.id, g.season) = 1;
 
+--   SELECT COUNT(*) INTO away_wins
+--   FROM GAME g, Team t
+--   WHERE g.idVisitorTeam = t.id AND isBestAtHome(t.id, g.season) = 0;
 
--- -- ? 8 - Quelle table contient des données incorrectes/incomplètes ? Game ou GameDetail ? Vérifier grâce aux résultats officiels des matchs.
+--     IF (home_wins >= away_wins) THEN
+--         RETURN 1;
+--     ELSE
+--         RETURN 0;
+--     END IF;
+-- END;
+-- $$ LANGUAGE plpgsql;
 
+-- CREATE OR REPLACE FUNCTION isBestAtHomeDuring(nbSeason numeric) RETURNS numeric AS $$
+-- DECLARE 
+--     home_wins integer;
+--     away_wins integer;
+-- BEGIN
+--   SELECT COUNT(*) INTO home_wins
+--   FROM GAME g, Team t
+--   WHERE g.idHomeTeam = t.id AND isBestAtHome(t.id, g.season) = 1;
 
--- ? 9 - Ecrire une fonction isBestAtHome qui retourne un booléen indiquant si une équipe donnée a
+--   SELECT COUNT(*) INTO away_wins
--- ? gagné au moins autant de matchs à domicile qu’à l’extérieur lors de la saison passée en paramètre.
+--   FROM GAME g, Team t
+--   WHERE g.idVisitorTeam = t.id AND isBestAtHome(t.id, g.season) = 0;
 
+--     IF (home_wins >= away_wins) THEN
+--         RETURN 1;
+--     ELSE
+--         RETURN 0;
+--     END IF;
+-- END;
+-- $$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION isBestAtHome(IdTeam Team.id%TYPE, GameSeason Game.season%TYPE) RETURNS numeric AS $$
+CREATE OR REPLACE FUNCTION isBestAtHomeDuring(teamID Team.id%TYPE, n integer) RETURNS boolean AS $$
 DECLARE
     home_wins integer;
     away_wins integer;
+    consecutive_seasons integer[];
 BEGIN
-  SELECT COUNT(*) INTO home_wins
+    -- Vérifier que n est une valeur valide (n doit être supérieur ou égal à 1)
-  FROM GAME g
+    IF n < 1 THEN
-  WHERE g.season = GameSeason AND g.idHomeTeam = IdTeam AND g.ptsHome > g.ptsAway;
+        RAISE EXCEPTION 'La valeur de n doit être d''au moins 1.';
-
-  SELECT COUNT(*) INTO away_wins
-  FROM GAME g
-  WHERE g.season = GameSeason AND g.idVisitorTeam = IdTeam AND g.ptsAway > g.ptsHome;
-
-    IF (home_wins >= away_wins) THEN
-        RETURN 1;
-    ELSE
-        RETURN 0;
     END IF;
-END;
-$$ LANGUAGE plpgsql;
 
--- ? 10 - Vérifier que l’équipe des Spurs a été meilleure à domicile qu’à l’extérieur pendant la saison 2021.
+    -- Initialiser le tableau des saisons avec des victoires à domicile
+    consecutive_seasons := ARRAY[]::integer[];
 
-SELECT isBestAtHome(id, '2021') AS best_at_home
+    -- Compter le nombre de saisons
-FROM Team
+    SELECT COUNT(DISTINCT season) INTO consecutive_seasons
-WHERE abbreviation = 'SAS';
+    FROM Game
+    WHERE idHomeTeam = teamID OR idVisitorTeam = teamID;
 
--- ? 11 - Ecrire une fonction bestAtHome qui retourne une table avec les équipes (ids, abbréviations, noms et villes) 
+    -- Itérer sur les saisons
--- ? qui ont gagné au moins autant de matchs à domicile qu’à l’extérieur lors de la saison passée en paramètre.
+    FOR i IN 1..consecutive_seasons - n + 1 LOOP
+        -- Vérifier si l'équipe a gagné au moins autant de matchs à domicile qu'à l'extérieur pendant n saisons consécutives
+        home_wins := (
+            SELECT COUNT(*)
+            FROM GAME g
+            WHERE g.season >= i
+            AND g.season <= i + n - 1
+            AND g.idHomeTeam = teamID
+            AND g.ptsHome > g.ptsAway
+        );
+
+        away_wins := (
+            SELECT COUNT(*)
+            FROM GAME g
+            WHERE g.season >= i
+            AND g.season <= i + n - 1
+            AND g.idVisitorTeam = teamID
+            AND g.ptsAway > g.ptsHome
+        );
+
+        -- Si l'équipe a gagné au moins autant de matchs à domicile qu'à l'extérieur pendant n saisons consécutives, retourner vrai
+        IF home_wins >= away_wins THEN
+            RETURN true;
+        END IF;
+    END LOOP;
 
-CREATE OR REPLACE FUNCTION BestAtHome(GameSeason Game.season%TYPE) 
+    -- Si l'équipe n'a pas gagné au moins autant de matchs à domicile qu'à l'extérieur pendant n saisons consécutives, retourner faux
-RETURNS TABLE(id Team.id%TYPE, abbreviation Team.abbreviation%TYPE, nom Team.nickname%TYPE, ville Team.city%TYPE) AS $$
+    RETURN false;
-BEGIN
-    RETURN QUERY SELECT DISTINCT t.id, t.abbreviation, t.nickname, t.city
-                    FROM Team t
-                    WHERE isBestAtHome(t.id, GameSeason) = 1;
 END;
 $$ LANGUAGE plpgsql;
 
--- ? 12 - Quelles équipes ont gagné au moins autant de matchs à domicile qu’à l’extérieur en 2021?
 
-SELECT BestAtHome(2021);
+SELECT isBestAtHomeDuring('1610612737', 2021);
 
--- ? 13 - Ecrire une fonction qui retourne un booléen indiquant si une équipe donnée à gagner au moins autant de matchs à 
+-- -- ? 14 - Y a t’il des équipes qui ont gagné au moins autant de matchs à domicile qu’à l’extérieur
--- ? domiciles qu’à l’extérieur pendant au moins n saisons consécutives, où n est un paramètre de la fonction.
+-- -- ? pendant 2 saisons consécutives ? Pendant 3 saisons consécutives ?
--- ? Cette fonction devra lever une exception personnalisée si n n’est pas une valeur possible.
 
-CREATE OR REPLACE FUNCTION isBestAtHomeDuring(nbSeason numeric) RETURNS numeric AS $$
-DECLARE 
-    home_wins integer;
-    away_wins integer;
-BEGIN
-  SELECT COUNT(*) INTO home_wins
-  FROM GAME g, Team t
-  WHERE g.idHomeTeam = t.id AND isBestAtHome(t.id, g.season) = 1;
-
-  SELECT COUNT(*) INTO away_wins
-  FROM GAME g, Team t
-  WHERE g.idVisitorTeam = t.id AND isBestAtHome(t.id, g.season) = 0;
-
-    IF (home_wins >= away_wins) THEN
-        RETURN 1;
-    ELSE
-        RETURN 0;
-    END IF;
-END;
-$$ LANGUAGE plpgsql;
-
--- SELECT isBestAtHomeDuring(5);
 
--- ? 14 - Y a t’il des équipes qui ont gagné au moins autant de matchs à domicile qu’à l’extérieur
--- ? pendant 2 saisons consécutives ? Pendant 3 saisons consécutives ?
 
+-- -- ? 15 - Écrire une fonction qui calcule l’id de l’équipe ayant le meilleur pourcentage moyen de paniers
+-- -- ? à 3 points d’une saison donnée.
 
+-- CREATE OR REPLACE FUNCTION idTeam3Points(GameSeason Game.season%TYPE) RETURNS numeric AS $$
+-- DECLARE
+--     idTeam Team.id%TYPE;
+-- BEGIN
+--     SELECT t.id INTO idTeam
+--     FROM Team t, GameDetail gd, Game g
+--     WHERE gd.idTeam = t.id AND gd.idGame = g.id AND g.season = GameSeason AND gd.threePointsPrctage >= ALL(SELECT threePointsPrctage
+--                                                                                                             FROM GameDetail gd1
+--                                                                                                             WHERE gd1.idTeam = t.id);
+--     RETURN idTeam;
+-- END;
+-- $$ LANGUAGE plpgsql;
 
--- ? 15 - Écrire une fonction qui calcule l’id de l’équipe ayant le meilleur pourcentage moyen de paniers
+-- -- ? 16 - Utiliser cette fonction pour afficher la meilleure équipe (abbréviation, nom et ville) de la saison 2021 en pourcentage moyen de paniers à 3 points
--- ? à 3 points d’une saison donnée.
-
-CREATE OR REPLACE FUNCTION idTeam3Points(GameSeason Game.season%TYPE) RETURNS numeric AS $$
-DECLARE
-    idTeam Team.id%TYPE;
-BEGIN
-    SELECT t.id INTO idTeam
-    FROM Team t, GameDetail gd, Game g
-    WHERE gd.idTeam = t.id AND gd.idGame = g.id AND g.season = GameSeason AND gd.threePointsPrctage >= ALL(SELECT threePointsPrctage
-                                                                                                            FROM GameDetail gd1
-                                                                                                            WHERE gd1.idTeam = t.id);
-    RETURN idTeam;
-END;
-$$ LANGUAGE plpgsql;
-
--- ? 16 - Utiliser cette fonction pour afficher la meilleure équipe (abbréviation, nom et ville) de la saison 2021 en pourcentage moyen de paniers à 3 points
 
-SELECT t.id, t.abbreviation, t.nickname, t.city
+-- SELECT t.id, t.abbreviation, t.nickname, t.city
-FROM Team t 
+-- FROM Team t 
-WHERE idTeam3Points('2021') = t.id;
+-- WHERE idTeam3Points('2021') = t.id;
 
--- ? 17 - Écrire une fonction qui calcule combien de paniers à trois points ont été marqué par un joueur donné, pendant une saison donnée.
+-- -- ? 17 - Écrire une fonction qui calcule combien de paniers à trois points ont été marqué par un joueur donné, pendant une saison donnée.
 
-CREATE OR REPLACE FUNCTION idTeam3Points(idPlayer Player.id%TYPE , GameSeason Game.season%TYPE) RETURNS numeric AS $$
+-- CREATE OR REPLACE FUNCTION idTeam3Points(idPlayer Player.id%TYPE , GameSeason Game.season%TYPE) RETURNS numeric AS $$
-DECLARE
+-- DECLARE
-    idTeam Team.id%TYPE;
+--     idTeam Team.id%TYPE;
-BEGIN
+-- BEGIN
-    SELECT t.id INTO idTeam
+--     SELECT t.id INTO idTeam
-    FROM Team t, GameDetail gd, Game g, Player p
+--     FROM Team t, GameDetail gd, Game g, Player p
-    WHERE gd.idTeam = t.id AND gd.idGame = g.id AND p.id = idPlayer AND g.season = GameSeason AND gd.threePointsPrctage >= ALL(SELECT threePointsPrctage
+--     WHERE gd.idTeam = t.id AND gd.idGame = g.id AND p.id = idPlayer AND g.season = GameSeason AND gd.threePointsPrctage >= ALL(SELECT threePointsPrctage
-                                                                                                            FROM GameDetail gd1
+--                                                                                                             FROM GameDetail gd1
-                                                                                                            WHERE gd1.idTeam = t.id);
+--                                                                                                             WHERE gd1.idTeam = t.id);
-    RETURN idTeam;
+--     RETURN idTeam;
-END;
+-- END;
-$$ LANGUAGE plpgsql;
+-- $$ LANGUAGE plpgsql;
 
--- ? 18 - Écrire une fonction qui calcule l’id du joueur ayant marqué le plus de paniers à trois points pendant une saison donnée.
+-- -- ? 18 - Écrire une fonction qui calcule l’id du joueur ayant marqué le plus de paniers à trois points pendant une saison donnée.
 
 
 
--- ? 19 - En utilisant les fonctions précédement créées, écrire un bloc anonyme qui affiche pour chaque saison, par ordre chronologique, 
+-- -- ? 19 - En utilisant les fonctions précédement créées, écrire un bloc anonyme qui affiche pour chaque saison, par ordre chronologique, 
--- ? le nom du joueur ayant marqué le plus de paniers à trois points ainsi que le nombres de paniers à trois points marqués.
+-- -- ? le nom du joueur ayant marqué le plus de paniers à trois points ainsi que le nombres de paniers à trois points marqués.
 
 
 
--- ? 20 - Ce calcul est très long. Pour effectuer un calcul plus efficace, nous allons créer une table supplémentaire permettant de stocker des statistiques.
+-- -- ? 20 - Ce calcul est très long. Pour effectuer un calcul plus efficace, nous allons créer une table supplémentaire permettant de stocker des statistiques.
--- ? Créer la table Stats(season, player, threePoints) contenant le nombre de paniers à trois points marqués par chaque joueur pendant une saison et 
+-- -- ? Créer la table Stats(season, player, threePoints) contenant le nombre de paniers à trois points marqués par chaque joueur pendant une saison et 
--- ? la remplir avec les données contenues dans GameDetail.
+-- -- ? la remplir avec les données contenues dans GameDetail.
--- ? △! Penser à éliminer les valeurs NULL.
+-- -- ? △! Penser à éliminer les valeurs NULL.

2A/systeme/tp/3_tp/pereFilsMultiple.c

@@ -9,21 +9,21 @@
 # define TAILLE_BUF 80 // 80 = taille d'une ligne
 
 
-void fermeTubesPere(int N, int **tubes) {
+void fermeTubesPere(int N, int tubes[N][2]) {
     int i;
     for (i=0 ; i<N ; i++) {
         close(tubes[i][0]);
     }
 }
 
-void fermeTubesFils(int N, int **tubes) {
+void fermeTubesFils(int N, int tubes[N][2]) {
     int i;
     for (i=0 ; i<N ; i++) {
         close(tubes[i][1]);
     }
 }
 
-void fermeAutresTubes(int N, int **tubes, int numTube) {
+void fermeAutresTubes(int N, int tubes[N][2], int numTube) {
     int i;
     for (i=0 ; i<N ; i++) {
         if(i != numTube) {
@@ -32,21 +32,21 @@ void fermeAutresTubes(int N, int **tubes, int numTube) {
     }
 }
 
-void fermeTubes(int N, int **tubes) {
+void fermeTubes(int N, int tubes[N][2]) {
     int i;
     for (i=0 ; i<N ; i++) {
         close(tubes[i][0]);
-        close(tubes[i][0]);
+        close(tubes[i][1]);
     }
 }
 
-void codeDuFils(int N, int **tubes, int numFils) {
+void codeDuFils(int N, int tubes[N][2], int numFils) {
     char buffer[TAILLE_BUF];
     unsigned int cpt = 0;
     // for(i=0;)
-    while(read(tubes[i][0], buffer, TAILLE_BUF)){
+    while (read(tubes[numFils][0], buffer, TAILLE_BUF)) {
         cpt++;
-        printf("\t\e[1;33mFils : %d : lecture de\e[1;31m %s\e[0m\n", cpt, buffer);
+        printf("\t\e[1;33mFils n° %d : %d : lecture de\e[1;31m %s\e[0m\n", numFils, cpt, buffer);
     }
     printf("Fils se termine sur fin de lecteure du tube\n");
     fermeTubesFils(N, tubes);
@@ -54,15 +54,12 @@ void codeDuFils(int N, int **tubes, int numFils) {
     exit(0);
 }
 
-void codeDuPere(int N, int **tubes) {
+void codeDuPere(int N, int tubes[N][2], int i) {
     char buffer[TAILLE_BUF];
 
     while(fgets(buffer, TAILLE_BUF, stdin) != NULL){
-        int i;
-        for (i=0 ; i<N ; i++) {
             write(tubes[i][1], buffer, TAILLE_BUF);
     }
-    }
 
     fermeTubes(N, tubes);
     wait(NULL);
@@ -81,12 +78,13 @@ int main(int argc, char *argv[])
         fputs("Donner un arg entier\n", stderr);
         exit(1);
     }
+
     N=atoi(argv[1]); 
     if (N <= 0 || N > 100) {
         fprintf(stderr, "N doit être un entier positif ou inférieur à 100.\n");
         exit(1);
     }
-    if(pipe(tubes)== -1) { 
+    if(pipe(tubes[0])== -1) { 
         perror(" pipe "); 
         exit(errno); 
     }
@@ -104,7 +102,7 @@ int main(int argc, char *argv[])
             exit(errno);
         }
         else if (pid==0) {
-            close(tubes[i][1]);
+            fermeTubesFils(i, tubes);
             codeDuFils(N, tubes, i);
             exit(0); 
             /* le ieme fils ne doit pas retourner dans la boucle */
@@ -112,59 +110,6 @@ int main(int argc, char *argv[])
     }
 
     fermeTubesPere(N, tubes);
-    codeDuPere();
+    codeDuPere(N, tubes, 3);
-
-
-    // switch(fork()) {
-    //     case -1 : 
-    //         perror(" fork "); 
-    //         exit(errno);
-    //     case 0 : // le fils
-    //         close(tube[1]);
-    //         codeDuFils(tube);
-    //         exit(0);
-    //     default : // le pere
-    //         close(tube[0]);
-    //         codeDuPere(tube);
-    // }
     return 0;
 }
-
-int main (int argc, char* argv[]){
-
- int i, etat, N;
- pid_t pid;
-
- if (argc!=2) {
-        fputs("Donner un arg entier\n", stderr);
-        exit(1);
-        }
-/* le atoi ne g<E8>re pas les erreurs
-  preferer le sscanf (un scanf dans une chaine) */
- N=atoi(argv[1]);       
-
- /* le pere va creer N fils */
- for (i=0 ; i<N ; i++) {
-        if((pid=fork())==-1) {
-                perror("pb fork");
-                exit(errno);
-                }
-        else if (pid==0) {
-                codeDuFils(i);
-                exit(0); 
-                /* le ieme fils ne doit pas retourner dans la boucle */
-                }
-        }
-
-  /* la suite n'est faite que par le p<E8>re */         
- for (i=0 ; i<N ; i++) {
-   if ((pid=wait(&etat))==-1) {perror("pb wait"); exit(errno);}
-   if (WIFEXITED(etat))
-        printf("(pere:) fils %d a retourne le code %d\n", pid, WEXITSTATUS(etat));
-   else
-        printf("(pere:) fils %d s'est mal termine\n", pid);
-   }
-  puts("(pere:) appli terminee");
-
- exit(0);
-}