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

\! clear
-- -- -- ? 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, 
-- -- -- ? 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)



-- -- -- ? 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.

-- -- SELECT calcul_rebonds(id)
-- -- FROM Game
-- -- WHERE dateGame = '2022-03-12';

-- -- --  calcul_rebonds 
-- -- -- ----------------
-- -- --              39
-- -- --              20
-- -- --              43
-- -- --              40
-- -- --              41
-- -- --              25
-- -- --              24
-- -- -- (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;

-- --     IF sumRebounds is NULL THEN 
-- --         RETURN 0;
-- --     END IF;

-- --     RETURN sumRebounds;
-- -- END;
-- -- $$ LANGUAGE plpgsql;

-- -- SELECT calcul_rebonds_t('22100979');

-- -- -- 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 $$
-- -- DECLARE
-- --     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
-- --         sumRebounds = sumRebounds + rbs;
-- --         FETCH curs INTO rbs;
-- --     END LOOP;
    
-- --     CLOSE curs;

-- --     RETURN sumRebounds;
-- -- END;
-- -- $$ 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 
-- -- -- ? ayant débuté la rencontre ont réalisé le plus de rebonds.

-- -- SELECT t1.abbreviation, t2.abbreviation, g.dateGame, calcul_rebonds_t(g.id)
-- -- 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 
-- -- -- --------------+--------------+------------+------------------
-- -- --  POR          | DEN          | 2019-05-03 |              101
-- -- -- (1 row)


-- -- -- ? 5 - Y a t’il des matchs pour lesquels les données sur les rebonds sont incohérentes? 
-- -- -- ? 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);


-- -- -- ? 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)
-- -- RETURNS integer as $$
-- -- DECLARE total integer;
-- -- BEGIN 
-- --     SELECT sum(points) INTO total
-- --     FROM GameDetail
-- --     WHERE idTeam = team AND idGame = match AND points IS NOT NULL;
    
-- --     IF total is NULL THEN 
-- --         RETURN 0;
-- --     END IF;

-- --     RETURN total;
-- -- END;
-- -- $$ LANGUAGE plpgsql; 


-- -- SELECT PtsTotJoueur('22101006','1610612741');

-- -- -- ? 7 - Utiliser cette fonction pour vérifier si les valeurs ptsHome et ptsAway de la table Game sont correctes.

-- -- 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
-- -- WHERE g.idVisitorTeam = t.id;


-- -- -- ? 8 - Quelle table contient des données incorrectes/incomplètes ? Game ou GameDetail ? Vérifier grâce aux résultats officiels des matchs.


-- -- ? 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.


-- CREATE OR REPLACE FUNCTION isBestAtHome(IdTeam Team.id%TYPE, GameSeason Game.season%TYPE) RETURNS numeric AS $$
-- DECLARE 
--     home_wins integer;
--     away_wins integer;
-- BEGIN
--   SELECT COUNT(*) INTO home_wins
--   FROM GAME g
--   WHERE g.season = GameSeason AND g.idHomeTeam = IdTeam AND g.ptsHome > g.ptsAway;

--   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';

-- ? 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 BestAtHome(2021);

-- ? 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.

CREATE OR REPLACE FUNCTION isBestAtHomeDuring(teamID Team.id%TYPE, n integer) RETURNS integer AS $$
DECLARE
    home_wins integer;
    away_wins integer;
    consecutive_seasons integer;
BEGIN
    -- Vérifier que n est une valeur valide (n doit être supérieur ou égal à 1)
    IF n < 1 THEN
        RAISE EXCEPTION 'La valeur de n doit être d''au moins 1.';
    END IF;

    -- Compter le nombre de saisons
    SELECT COUNT(DISTINCT season) INTO consecutive_seasons
    FROM Game
    WHERE idHomeTeam = teamID OR idVisitorTeam = teamID;

    -- Vérifier si l'équipe a gagné au moins autant de matchs à domicile qu'à l'extérieur pour n saisons consécutives
    FOR i IN 1..consecutive_seasons - n + 1 LOOP
        SELECT COUNT(*) INTO home_wins
        FROM Game
        WHERE season BETWEEN i AND i + n - 1
            AND idHomeTeam = teamID
            AND ptsHome > ptsAway;

        SELECT COUNT(*) INTO away_wins
        FROM Game
        WHERE season BETWEEN i AND i + n - 1
            AND idVisitorTeam = teamID
            AND ptsAway > ptsHome;

        IF home_wins >= away_wins THEN
            RETURN 1;
        END IF;
    END LOOP;

    RETURN 0;
END;
$$ LANGUAGE plpgsql;


SELECT isBestAtHomeDuring('1610612737', 1) AS best_at_home_during_one_seasons;

-- ? 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 ?

SELECT isBestAtHomeDuring('1610612737', 2) AS best_at_home_during_two_seasons;

SELECT isBestAtHomeDuring('1610612737', 3) AS best_at_home_during_three_seasons;


-- ? 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 numeric) RETURNS character varying AS $$
DECLARE
    bestTeamID character varying;
BEGIN
    SELECT INTO bestTeamID gd.idTeam
    FROM GameDetail gd, Game g
    WHERE gd.idGame = g.id AND g.season = GameSeason
    GROUP BY gd.idTeam
    ORDER BY AVG(gd.threePointsPrctage) DESC
    LIMIT 1;

    RETURN bestTeamID;
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 abbreviation, nickname, city
FROM Team
WHERE id = idTeam3Points('2021');

-- ! charge infiniment

-- ? 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 count3pointsbyplayer(idP character varying, GameSeason numeric) RETURNS numeric AS $$
DECLARE
    totalThreePoints numeric;
BEGIN
    SELECT SUM(gd.threePointsMade)
    INTO totalThreePoints
    FROM GameDetail gd
    JOIN Game g ON gd.idGame = g.id
    WHERE gd.idPlayer = idP AND g.season = GameSeason;
    
    RETURN totalThreePoints;
END;
$$ LANGUAGE plpgsql;

SELECT count3pointsbyplayer('203932', '2021');


-- ? 18 - Écrire une fonction qui calcule l’id du joueur ayant marqué le plus de paniers à trois points pendant une saison donnée.

CREATE OR REPLACE FUNCTION idPlayerMost3Points(GameSeason Game.season%TYPE) RETURNS Player.id%TYPE AS $$
DECLARE
    best_player_id Player.id%TYPE;
BEGIN
    SELECT gd.idPlayer INTO best_player_id
    FROM GameDetail gd
    JOIN Game g ON gd.idGame = g.id
    WHERE g.season = GameSeason
    GROUP BY gd.idPlayer
    ORDER BY SUM(gd.threePointsMade) DESC
    LIMIT 1;
    
    RETURN best_player_id;
END;
$$ LANGUAGE plpgsql;

SELECT idPlayerMost3Points('2021');


-- ? 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.

DO $$
DECLARE
    season_value Game.season%TYPE;
    player_id Player.id%TYPE;
    total_3_points numeric;
BEGIN
    FOR season_value IN (SELECT DISTINCT season FROM Game ORDER BY season) LOOP
        player_id := idPlayerMost3Points(season_value);
        total_3_points := count3PointsByPlayer(player_id, season_value);
        RAISE NOTICE 'Saison %: Joueur ID %, Nombre de paniers à trois points : %', season_value, player_id, total_3_points;
    END LOOP;
END;
$$;


-- ? 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 
-- ? la remplir avec les données contenues dans GameDetail.
-- ? △! Penser à éliminer les valeurs NULL.

CREATE TABLE Stats (
    season numeric,
    player varchar(10),
    threePoints numeric
);



-- Insertion des données de GameDetail dans la table Stats
INSERT INTO Stats (season, player, threePoints)
    SELECT g.season, gd.idPlayer, SUM(gd.threePointsMade)
    FROM GameDetail gd, Game g
    WHERE gd.idGame = g.id AND gd.threePointsMade IS NOT NULL
    GROUP BY g.season, gd.idPlayer;