Objectif

Actualiser les lots de données suivants dans la base de données PostgreSQL de la plate-forme SIGLoire :

  • n_commune_ign_r52
  • n_departement_ign_r52
  • n_epci_zsup_r52
  • n_region_ign_r52

Chargement des librairies

library(datalibaba)
library(yaml)

Configuration

Chargement des variables

À faire impérativement : configurer ou vérifier les paramètres du fichier config.yml avant chargement.

Les paramètres suivants sont ensuite récupérés :

  • chemin d’accès du fichier GPKG source
  • base de données locale
  • schéma local
  • rôle de connexion local
  • emprise des lots de données locaux : ici région Pays de la Loire
  • hôte : nom de domaine ou adresse IP de la plate-forme de diffusion
  • port de la plate-forme de diffusion
  • base de données dans laquelle mettre à jour les données
  • schéma de la plate-forme de diffusion
  • clé primaire pour les lots de données sur la plate-forme de diffusion
  • rôle de connexion à la plate-forme de diffusion
# Charger le fichier YAML
config <- yaml::read_yaml("../config.yml")

# Récupérer les variables
fichier_gpkg <- config$fichier_gpkg
database <- config$database
schema_name <- config$schema_name
primary_key <- config$primary_key
role <- config$role
emprise <- config$emprise
host_platform <- config$host_platform
port_platform <- config$port_platform
database_platform <- config$database_platform
schema_name_platform <- config$schema_name_platform
role_platform <- config$role_platform
password_platform <- config$password_platform

Chargement des lots de données régionaux

# Liste des entités concernées
entities <- c("commune", "departement", "epci", "region")

# Liste pour stocker les dataframes
tables_list <- list()

for (entity in entities) {
  table_name <- paste0("n_", entity, "_exp_", emprise)
  nom_var <- paste0("n_", entity, "_exp_", emprise)
  
  tryCatch({
    # Filtrage dynamique avec .data[[...]] et affectation dans l'environnement global
    df <- datalibaba::importer_data(
      table = table_name,
      schema = schema_name,
      db = database,
      user = role)
    
    # Stockage dans la liste sous le nom final
    tables_list[[nom_var]] <- df
    # Création en objet dans l’environnement global
    assign(nom_var, df, envir = .GlobalEnv)
    
    message(sprintf("DataFrame créé : %s", nom_var))
  },
  error = function(e) {
    message(sprintf("Erreur lors du chargement ou filtrage de la table '%s' : %s", 
                    table_name, e$message))
  })
}

Publication dans la base de données de SIGLoire

Adaptation de la structure des tables

Objectif : adapter la structure des données issues de la base DREAL (source : ADMIN EXPRESS v4) à celle des tables de la base PRODIGE

Communes

n_commune_exp_r52_final <- n_commune_exp_r52 |> 
  dplyr::left_join(n_departement_exp_r52 |> 
                     sf::st_drop_geometry() |> 
                     dplyr::select(code_insee, 
                                   nom_dep = nom_officiel_en_majuscules), 
                   by = c("code_insee_du_departement" = "code_insee") ) |> 
  dplyr::left_join(n_region_exp_r52 |> 
                     sf::st_drop_geometry() |> 
                     dplyr::select(code_insee, 
                                   nom_reg = nom_officiel_en_majuscules), 
                   by = c("code_insee_de_la_region" = "code_insee") ) |> 
  dplyr::select(nom_com = nom_officiel_en_majuscules, 
                insee_com = code_insee, 
                statut, 
                population, 
                code_insee_de_l_arrondissement, 
                nom_dep, 
                insee_dep = code_insee_du_departement,
                nom_reg,
                insee_reg = code_insee_de_la_region, 
                the_geom)

Départements

n_departement_exp_r52_final <- n_departement_exp_r52 |>
  dplyr::select(
    nom_dep = nom_officiel_en_majuscules,
    insee_dep = code_insee,
    insee_reg = code_insee_de_la_region,
    the_geom)

EPCI

n_epci_zsup_r52_final <- n_epci_exp_r52 |>
  dplyr::mutate(
    nj_epci = NA_character_,
    fisc_epci = NA_character_,
    nb_com = NA_character_,
    ptot_epci = NA_character_,
    pmun_epci = NA_character_
  ) |>
  dplyr::select(
    dep_epci = codes_insee_des_departements_membres, # valeurs multiples, modification à faire en base au préalable
    siren_epci = code_siren,
    nom_epci = nom_officiel,
    nj_epci,
    fisc_epci,
    nb_com,
    ptot_epci,
    pmun_epci,
    the_geom)

Région

n_region_exp_r52_final <- n_region_exp_r52 |>
  dplyr::select(
    nom_reg = nom_officiel_en_majuscules,
    insee_reg = code_insee,
    the_geom)

Mise à jour des tables dans la base PRODIGE

Objectif : mettre à jour les données dans la base PRODIGE sans modifier la structure des tables

Il est nécessaire de vérifier ensuite sur la plate-forme que la mise à jour des tables n’entraîne pas de problèmes de visualisation.

Communes

datalibaba::poster_data(data = n_commune_exp_r52_final,
                        table = "n_commune_ign_r52",
                        schema = schema_name_platform,
                        db = database_platform,
                        port = port_platform,
                        server = host_platform,
                        user = "prodige",
                        truncate = TRUE)

Départements

datalibaba::poster_data(data = n_departement_exp_r52_final,
                        table = "n_departement_ign_r52",
                        schema = schema_name_platform,
                        db = database_platform,
                        port = port_platform,
                        server = host_platform,
                        user = "prodige",
                        truncate = TRUE)

EPCI

datalibaba::poster_data(data = n_epci_zsup_r52_final,
                        table = "n_epci_zsup_r52",
                        schema = schema_name_platform,
                        db = database_platform,
                        port = port_platform,
                        server = host_platform,
                        user = "prodige",
                        truncate = TRUE)

Région

datalibaba::poster_data(data = n_region_exp_r52_final,
                        table = "n_region_ign_r52",
                        schema = schema_name_platform,
                        db = database_platform,
                        port = port_platform,
                        server = host_platform,
                        user = "prodige",
                        truncate = TRUE)

Mise à jour des commentaires sur les tables

Récupération des commentaires existants

# Liste des entités concernées
entities <- c("commune", "departement", "epci", "region")

# Liste pour stocker les dataframes
tables_list <- list()

for (entity in entities) {
  table_name <- paste0("n_", entity, "_exp_", emprise)  # adapter le nom de la table pour les EPCI
  nom_var <- paste0("n_", entity, "_exp_", emprise,"_comment")
  
  tryCatch({
    # Filtrage dynamique avec .data[[...]] et affectation dans l'environnement global
    df <- datalibaba::get_table_comment(
      table = table_name,
      schema = schema_name,
      db = database,
      user = role)
    
    # Stockage dans la liste sous le nom final
    tables_list[[nom_var]] <- df
    # Création en objet dans l’environnement global
    assign(nom_var, df, envir = .GlobalEnv)
    
    message(sprintf("DataFrame créé : %s", nom_var))
  },
  error = function(e) {
    message(sprintf("Erreur lors du chargement des commentaires de la table '%s' : %s", 
                    table_name, e$message))
  })
}

Mise à jour des commentaires des tables dans la base PRODIGE

# Liste des entités concernées
entities <- c("commune", "departement", "epci", "region")

# Liste pour stocker les dataframes
tables_list <- list()

for (entity in entities) {
  table_name <- paste0("n_", entity, "_ign_", emprise)
  nom_var <- paste0("n_", entity, "_exp_", emprise,"_comment")
  
  tryCatch({
    # Filtrage dynamique avec .data[[...]] et affectation dans l'environnement global
    df <- datalibaba::commenter_table(
      dico = nom_var$commentaire,
      table = table_name,
      schema = schema_name_platform,
      db = database_platform,
      port = port_platform,
      server = host_platform,
      user = "prodige",
      user = role)
    
    # Stockage dans la liste sous le nom final
    tables_list[[nom_var]] <- df
    # Création en objet dans l’environnement global
    assign(nom_var, df, envir = .GlobalEnv)
    
    message(sprintf("DataFrame créé : %s", nom_var))
  },
  error = function(e) {
    message(sprintf("Erreur lors de la publication des commentaires de la table '%s' : %s", 
                    table_name, e$message))
  })
}