Génération automatique de rapports selon un planning

Quand tu bosses avec des petites bases de données, lancer manuellement des requêtes ou des procédures pour faire des rapports, c’est pas bien grave. Mais dans la vraie vie, les bases grossissent et toutes les tâches répétitives doivent être automatisées. Imagine qu’on te demande chaque jour de préparer un rapport sur les ventes. Même si la requête prend deux minutes, sur un an tu vas passer plus de 12 heures juste à cliquer sur “Exécuter”. Franchement, tu pourrais passer ce temps à boire un café pendant que la procédure automatique fait tout à ta place.

L’automatisation permet de :

• Réduire le travail manuel.
• Assurer la régularité des rapports (genre rapports quotidiens, hebdos, etc).
• Minimiser les risques d’erreurs humaines.
• Augmenter la confiance dans tes rapports : ils sont toujours générés selon les paramètres définis.

Étapes principales de la génération automatique de rapports

L’exécution automatique des rapports passe par ces étapes :

1. Créer une procédure en PL/pgSQL qui génère le rapport.
2. Configurer la journalisation des résultats (si besoin).
3. Utiliser un planificateur de tâches pour lancer la procédure selon un planning.

Allez, on va faire ça étape par étape !

Créer une procédure pour générer un rapport

Pour commencer, on va écrire une petite procédure qui calcule le chiffre d’affaires total de toutes les commandes du jour et sauvegarde le résultat dans une table de logs. Notre table de logs existe déjà (on va l’appeler sales_report_log) :

CREATE TABLE sales_report_log (
    report_date DATE NOT NULL,
    total_sales NUMERIC NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Maintenant, on crée la procédure en PL/pgSQL :

CREATE OR REPLACE FUNCTION generate_daily_sales_report()
RETURNS VOID AS $$
BEGIN
    -- Calculer le chiffre d’affaires total pour aujourd’hui
    INSERT INTO sales_report_log (report_date, total_sales)
    SELECT CURRENT_DATE, SUM(order_total)
    FROM orders
    WHERE order_date = CURRENT_DATE;

    RAISE NOTICE 'Le rapport pour % a été créé avec succès', CURRENT_DATE;
END;
$$ LANGUAGE plpgsql;

Ce qui se passe ici :

• On utilise la fonction d’agrégation SUM() pour calculer le chiffre d’affaires total depuis la table orders.
• La date du rapport (report_date) est toujours la date du jour (CURRENT_DATE).
• Le résultat est sauvegardé dans la table sales_report_log.
• Le message RAISE NOTICE sert au debug : il indique que le rapport a bien été créé.

Tester la procédure

Avant d’automatiser l’exécution de cette procédure, c’est toujours une bonne idée de la tester à la main. On lance la fonction :

SELECT generate_daily_sales_report();

Et maintenant, on vérifie le contenu de la table sales_report_log :

SELECT * FROM sales_report_log;

Si tu vois une ligne avec la date du jour et la bonne valeur de chiffre d’affaires — félicitations, ta fonction marche !

Automatisation des tâches dans PostgreSQL

Parfois, c’est cool que la base fasse des trucs toute seule : lancer des rapports, nettoyer les vieilles lignes ou mettre à jour des agrégats selon un planning. PostgreSQL permet ça avec l’extension pg_cron ou un planificateur externe — le cron système ou Task Scheduler.

Si tu bosses sous Linux, le meilleur choix c’est pg_cron. Cette extension lance du SQL direct dans PostgreSQL, pas besoin de shell ou de scripts externes.

Pour installer pg_cron (n’oublie pas de remplacer XX par ta version de PostgreSQL) :

sudo apt install postgresql-XX-cron

Après l’installation, il faut l’activer dans la config. Ouvre postgresql.conf et ajoute la ligne :

shared_preload_libraries = 'pg_cron'

Puis redémarre PostgreSQL et active l’extension dans ta base :

CREATE EXTENSION pg_cron;

Maintenant, tu peux planifier une tâche. Par exemple, lancer la fonction generate_daily_sales_report() tous les jours à minuit :

SELECT cron.schedule(
    'daily_sales_report',
    '0 0 * * *',
    $$ SELECT generate_daily_sales_report(); $$
);

Ici :

• 'daily_sales_report' — le nom de la tâche ;
• '0 0 * * *' — le planning façon cron (ici, tous les jours à 00:00) ;
• Le SQL entre $$ — c’est le code qui sera exécuté.

Pour voir toutes les tâches planifiées, utilise :

SELECT * FROM cron.job;

Si tu es sous Windows ou macOS, pg_cron n’est pas supporté (sous Windows) ou il faut le compiler à la main (sous macOS). C’est galère, donc dans la plupart des cas, c’est plus simple d’utiliser le planificateur système.

Voilà comment faire :

1. Crée un fichier SQL avec la commande qu’il te faut :

echo "SELECT generate_daily_sales_report();" > /path/to/script.sql

2. Utilise psql pour exécuter le fichier :

psql -h localhost -U postgres -d your_database -f /path/to/script.sql

3. Ajoute cette commande dans le planificateur de tâches :

   • Sur Linux/macOS : via crontab -e :

     0 0 * * * psql -h localhost -U postgres -d your_database -f /path/to/script.sql
     

   • Sur Windows : via Task Scheduler, en créant une tâche qui lance psql.exe avec les bons paramètres.

• Si tu es sous Linux, utilise pg_cron — c’est pratique et intégré à PostgreSQL.
• Si tu es sous Windows ou Mac, c’est plus simple de passer par le planificateur système (cron ou Task Scheduler) et de lancer le SQL via psql.

Comme ça, tu peux automatiser n’importe quelle tâche dans PostgreSQL sans te prendre la tête.

Exemples de reporting automatique

1. Rapport quotidien par région

Imaginons que tu veuilles générer automatiquement un rapport sur le chiffre d’affaires par région. Tu peux étendre notre fonction :

CREATE OR REPLACE FUNCTION generate_regional_sales_report()
RETURNS VOID AS $$
BEGIN
    INSERT INTO regional_sales_report_log (region, report_date, total_sales)
    SELECT region, CURRENT_DATE, SUM(order_total)
    FROM orders
    WHERE order_date = CURRENT_DATE
    GROUP BY region;

    RAISE NOTICE 'Le rapport régional pour % a été créé avec succès', CURRENT_DATE;
END;
$$ LANGUAGE plpgsql;

2. Rapport mensuel

De la même façon, tu peux créer une procédure pour générer un rapport mensuel. Il suffit de changer le filtre dans la requête :

WHERE order_date BETWEEN date_trunc('month', CURRENT_DATE)
                     AND date_trunc('month', CURRENT_DATE) + interval '1 month - 1 day';

Erreurs courantes et comment les éviter

Quand tu fais du reporting automatique, tu peux tomber sur quelques soucis :

• Erreur de syntaxe dans la fonction : teste toujours tes fonctions à la main avant d’automatiser.
• Fréquence d’exécution des tâches : si la tâche tourne trop souvent, ça peut surcharger la base. Choisis bien le planning.
• Doublons de données : si le rapport est lancé plusieurs fois par jour, tu risques d’avoir des doublons. Utilise des clés uniques pour éviter ça.

Cette leçon t’a montré comment mettre en place la génération automatique de rapports dans PostgreSQL. Maintenant, tu peux optimiser tes process analytiques et garder plus de temps pour les trucs importants… genre chasser les bugs, coder ou rêver à la perfection de tes requêtes SQL.