Chargement des librairies

library(datalibaba)
library(dplyr)
library(sf)
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 de travail : chargement des tables dans les bases referentiels et si_eau
  • schéma de travail
  • clé primaire
  • rôle de connexion
  • emprise des des lots de données : ici région Pays de la Loire
# 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

Édition du millésime

Récupération du mois et de l’année de l’édition d’ADMIN EXPRESS téléchargée à partir du nom du fichier GPKG :

# Extraire la date après '-ED' dans le nom de fichier
date_part <- sub(".*-ED([0-9]{4}-[0-9]{2}-[0-9]{2})\\.gpkg$", "\\1", 
                 basename(fichier_gpkg))

# Définir la date
date <- lubridate::ymd(date_part)

# Extraire le mois et l'année
edition <- format(date, "%B %Y")

Chargement des lots de données régionaux à partir des tables France entière

Lots de données filtrés avec l’identifiant régional

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

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

for (entity in entities) {
  table_name <- paste0("n_", entity, "_exp_000")
  nom_var <- paste0("n_", entity, "_exp_", emprise)
  
  # Condition sur le nom de la colonne de filtrage
  if (entity == "region") { filtre_colonne <- "code_insee"
  } else { filtre_colonne <- "code_insee_de_la_region" }
  
  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) |>
      # Filtrage sur la valeur de l'emprise sans la lettre au début de la chaîne
      dplyr::filter(.data[[filtre_colonne]] == 
                      substr(emprise, nchar(emprise) - 1, nchar(emprise)))
    
    # 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))
  })
}

Lots de données avec un filtrage spécifique

Communes associées ou déléguées

Filtrage par sélection des code INSEE des communes de rattachemment correspondant aux départements de la région :

tryCatch({
  # Filtrage sur le champ code_insee_de_la_commune_de_rattach
  n_commune_associee_ou_deleguee_exp_r52 <- 
    datalibaba::importer_data(table = "n_commune_associee_ou_deleguee_exp_000",
                              schema = schema_name,
                              db = database,
                              user = role) |>
    dplyr::filter(grepl("^(44|49|53|72|85)", 
                        code_insee_de_la_commune_de_rattach))
  message(paste0("DataFrame créé : n_commune_associee_ou_deleguee_exp_", emprise))
},
error = function(e) {
  message(sprintf("Erreur lors du chargement ou filtrage de la table 'n_commune_associee_ou_deleguee_exp_%s' : %s", 
                  emprise, e$message))
})

EPCI

Filtrage par sélection des départements concernés :

tryCatch({
  # Filtrage sur le champ codes_insee_des_departements_membres
  n_epci_exp_r52 <- datalibaba::importer_data(table = "n_epci_exp_000",
                                          schema = schema_name,
                                          db = database,
                                          user = role) |>
    dplyr::filter(grepl("\\b44\\b|\\b49\\b|\\b53\\b|\\b72\\b|\\b85\\b", 
                        codes_insee_des_departements_membres))
  message(paste0("DataFrame créé : n_epci_exp_", emprise))
},
error = function(e) {
  message(sprintf("Erreur lors du chargement ou filtrage de la table 'n_epci_exp_%s' : %s", 
                  emprise, e$message))
})

Publication des lots de données régionaux en base

# Lister tous les objets en mémoire dont le nom se termine par _r52
df_names <- ls(pattern = paste0(emprise, "$"))

for (df_name in df_names) {
  # Récupérer le dataframe par son nom sous forme d'objet
  df <- get(df_name, envir = .GlobalEnv)
  
  # Utiliser nom de l'objet comme nom de table cible
  tryCatch({
    poster_data(
      data = df,
      table = df_name,
      schema = schema_name,
      db = database,
      pk = primary_key,
      user = role,
      overwrite = TRUE
    )
    message(sprintf("Table publiée avec succès : %s", df_name))
  }, error = function(e) {
    message(sprintf("Erreur lors de la publication de %s.%s : %s", 
                    schema_name, df_name, e$message))
  })
}

Ajout des commentaires sur les lots de données régionaux

Arrondissements

# Commentaire sur la table
comment_arrondissement <- 
  paste0("Arrondissements en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_arrondissement, 
                            table = "n_arrondissement_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_arrondissement.R")
datalibaba::post_dico_attr(dico = dico_arrondissement, 
                           table = "n_arrondissement_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Cantons

# Commentaire sur la table
comment_canton <- 
  paste0("Cantons en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_canton, 
                            table = "n_canton_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_canton.R")
datalibaba::post_dico_attr(dico = dico_canton, 
                           table = "n_canton_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Communes

# Commentaire sur la table
comment_commune <- 
  paste0("Communes en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_commune, 
                            table = "n_commune_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_commune.R")
datalibaba::post_dico_attr(dico = dico_commune, 
                           table = "n_commune_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Communes associées ou déléguées

# Commentaire sur la table
comment_commune_associee_ou_deleguee <- 
  paste0("Communes associées ou déléguées en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_commune_associee_ou_deleguee, 
                            table = "n_commune_associee_ou_deleguee_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_commune_associee_ou_deleguee.R")
datalibaba::post_dico_attr(dico = dico_commune_associee_ou_deleguee, 
                           table = "n_commune_associee_ou_deleguee_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Départements

# Commentaire sur la table
comment_departement <- 
  paste0("Départements en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_departement, 
                            table = "n_departement_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_departement.R")
datalibaba::post_dico_attr(dico = dico_departement, 
                           table = "n_departement_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

EPCI

# Commentaire sur la table
comment_epci <- 
  paste0("EPCI en Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_epci, 
                            table = "n_epci_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_epci.R")
datalibaba::post_dico_attr(dico = dico_epci, 
                           table = "n_epci_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Région

# Commentaire sur la table
comment_region <- 
  paste0("Région Pays de la Loire (ADMIN-EXPRESS édition ", 
         edition, ")")
datalibaba::commenter_table(comment_region, 
                            table = "n_region_exp_r52", 
                            schema = schema_name, 
                            db = database, 
                            user = role)

# Commentaires sur les champs
source("../data/dico_region.R")
datalibaba::post_dico_attr(dico = dico_region, 
                           table = "n_region_exp_r52", 
                           schema = schema_name, 
                           db = database, 
                           user = role)

Gestion des droits sur les tables

# Connection à la base de données
connexion <- datalibaba::connect_to_db(db = database, user = role)

requete_grant_csd_adl <- 
  sprintf("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA %s TO %s", 
          schema_name, role)
DBI::dbExecute(connexion, requete_grant_csd_adl)

requete_grant_writer_referentiels <- 
  sprintf("GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA %s TO writer_referentiels", 
          schema_name)
DBI::dbExecute(connexion, requete_grant_writer_referentiels)

requete_grant_reader_referentiels <- 
  sprintf("GRANT SELECT ON ALL TABLES IN SCHEMA %s TO reader_referentiels", 
          schema_name)
DBI::dbExecute(connexion, requete_grant_reader_referentiels)

# Fermeture de la connection
DBI::dbDisconnect(connexion)