Pratiquer R sur le portail SNDS

Compléments d’un utilisateur au guide Cnam

Ce tutoriel est le fruit de mes découvertes sur le portail R et n’engage que moi. Ce n’est évidemment pas la seule manière de travailler sur le portail R. Tous les éléments de code devraient fonctionner à condition que vous ayez accès à l’Echantillon SNDS (ESND) qui est utilisé comme exemple. C’est le cas de tous les accès permanents au SNDS.

Vous pouvez télécharger le .Rmd pour exécuter le code vous-même en sélectionnant le bouton en haut à droite de cette page “Code ▾” puis “Download Rmd”

1 Comment accéder à R ?

La démarche d’accès est expliquée dans le document R - Accès à R sur portail SNDS.pdf que l’on trouve dans l’onglet Accueil du portail.

2 Ressources à lire

• (indispensable) guide utilisateur de la Cnam, R - Guide_utilisateur_RStudio_ V1.2.pdf que l’on trouve dans l’onglet Accueil du portail. Les informations les plus importantes s’y trouvent et ce tutoriel ne fait que compléter.
  Ce tutoriel n’est pas compréhensible sans le guide de la Cnam.
• (utile) les conseils de R - Accès à R sur portail SNDS.pdf que l’on trouve dans l’onglet Accueil du portail.
• (utile si on ne connaît pas bien R, peu utile sinon) le support de la formation R proposée par la Cnam que l’on trouvera sur le portail (“Tableaux et requêtes” > SAP BusinesObjects > Documents > Dossiers > SNIIRAM > _Documentation SNIIRAM-SNDS > Formation > support des formations SNIIRAM > 11-Logiciels R). Plutôt généraliste, pour apprendre R, très peu de points spécifiques au SNDS.
• (utile) le Guide de bonnes pratiques SAS - v2.1.pdf qui se trouve sur la page d’accueil du portail. Un certain nombre de points sur l’optimisation des codes valent aussi pour R.
• (utile) le support de formation Données individuelles bénéficiaires, à relire deux fois par semaine, et que l’on trouvera sur le portail (“Tableaux et requêtes” > SAP BusinesObjects > Documents > Dossiers > SNIIRAM > _Documentation SNIIRAM-SNDS > Formation > support des formations SNIIRAM > 7-DIB).

3 Paramétrage de RStudio

La Cnam a rappelé par mail quelques paramètres importants pour RStudio, qui valent d’ailleurs au-delà du portail de la Cnam. Ils évitent de recharger les objets au démarrage de la session, ce qui peut être très long.

Dans le menu Tools > Global Options :

• Désactiver « Restore most recently open project at startup »
• Désactiver « Restore .RData into workspace at startup »
• Désactiver « Save workspace to .RData on exit »

4 Connexion à la base de données

On apprend dans R - Guide_utilisateur_RStudio_ V1.2.pdf que ce bloc est indispensable :

library(ROracle) # charger le package Roracle
drv <- dbDriver("Oracle") # obtenir le pilote pour se connecter à une base oracle
conn <- dbConnect(drv, dbname = "IPIAMPR2.WORLD") # se connecter à la base IPIAMPR2.WORLD
Sys.setenv(TZ = "Europe/Paris") # fuseaux horaires
Sys.setenv(ORA_SDTZ = "Europe/Paris")

Il permet de se connecter à la base de données Oracle de la Cnam. Vous pourriez être tenté par une connexion via le pannel Connections de RStudio mais cela n’est pas possible. Pour l’explication technique, RStudio ne supporte à ce jour que les connexions ODBC et Spark tandis que ROracle utilise une connexion DBI.

On crée une fausse table pour le tutoriel.

# Créer un jeu ex nihilo 
faux0 <- data.frame(x = 1:4, y = c(1, NA), z = c(rep("A",3), "B"))
try(dbRemoveTable(conn, "PROV"), silent = T) # supprimer la table si elle existe déjà, sinon erreur
dbWriteTable(conn, "PROV", faux0) # écrire la table
faux <- tbl(conn, "PROV") # charger la table

5 Les deux manières : SQL ou dplyr

La guide de la Cnam propose de travailler soit en SQL Oracle soit en syntaxe dplyr. Illustration et comparaison :

5.1 Exemple SQL Oracle

Exemple : on récupère le référentiel de biologie.

dbGetQuery(conn, "select * from ir_bio_r")[1:5,]

⚠ ne pas utiliser fetch first 100 rows only qui n’est pas optimisé et n’aboutit pas (explications) comme dans la commande suivante :

# NE PAS EXECUTER, N'ABOUTIT PAS
# dbGetQuery(conn, "select * from ER_PRS_F fetch first 100 rows only")

Alors que celle-ci est immédiate (commentée car il s’agit de résultats individuels non publiables) :

# dbGetQuery(conn, "SELECT * FROM ER_PRS_F WHERE ROWNUM <= 100.0")

5.2 Exemple Dplyr

Exemple : on récupère le référentiel de biologie.

library(dplyr) # le paquet dplyr est nécessaire pour cette méthode
library(dbplyr) # je recommande de charger également dbplyr pour quelques fonctions suppémentaires

irbior <- tbl(conn, "IR_BIO_R")
irbior %>% collect %>% head(5)

5.3 Quelle manière choisir ?

Les habitués de SAS préféreront peut-être travailler directement en SQL en envoyant les requêtes via dbGetQuery(). Personnellement, et même si je n’aime pas dplyr en temps normal, je trouve la manière dplyr beaucoup plus souple. En particulier elle permet de faire les choses progressivement grâce à l’évaluation paresseuse (lazy). Le logiciel n’exécute pas directement chaque étape mais les enregistre jusqu’au moment où il n’a plus le choix, par exemple lorsqu’on lui demande un comptage.

Exemple : on peut créer un objet erprsf avec des filtres usuels sur ESND_ER_PRS_F (échantillon SNDS, 2% des bénéficiaires). Si l’on ne collecte pas le résultat, l’opération est immédiate puisqu’on ne réalise pas réellement le filtre. Ensuite, on a tout le loisir de repartir de cet objet pour filtrer sur telle et telle prestation. Un dbGetQuery sur ERE_PRS_F avec des filtres usuels serait impossible car demanderait trop de ressources en mémoire vive. Donc il faudrait, pour chaque ciblage de prestation, remettre tous les filtres depuis ERE_PRS_F si l’on passait par SQL Oracle. Traduction en code :

# Immédiat (évaluation paresseuse)
erprsf <- tbl(conn, in_schema("MEPSGP_156", "ESND_ER_PRS_F")) %>%
    filter(
        FLX_DIS_DTD - EXE_SOI_DTD < 183 & # on enlève
        # les soins remontés 6 mois après la date de début pour raisonner à durée de flux contante
        DPN_QLF != 71 &
        PRS_DPN_QLP != 71 &
        CPL_MAJ_TOP < 2 &
        CPL_AFF_COD != 16 &
        (!BEN_SEX_COD %in% c("0")) &
        BEN_NAI_ANN > 1800 &
        BEN_NAI_ANN <= 2016
    ) %>%
  select(BEN_NIR_PSA, BEN_RNG_GEM, BEN_SEX_COD, BEN_AMA_COD, BEN_RES_DPT, BEN_RES_COM, FLX_DIS_DTD, EXE_SOI_AMD, EXE_SOI_DTD, PRS_NAT_REF, PSE_ACT_NAT, PSE_SPE_COD, PRS_ACT_QTE)

Filtrer les vaccins contre la grippe (codes prestations 3331) en repartant de l’objet erprsf :

erprsf %>% filter(PRS_NAT_REF == "3331") %>% tally

Filtrer les soins des médecins généralistes (codes spécialité 1, 22 ou 23) en repartant de l’objet erprsf :

erprsf %>% filter(PSE_SPE_COD %in% c(1, 22, 23)) %>% tally

La plupart des commandes présentées ensuite concernent la manière dplyr.

5.4 REGLE D’OR

Il faut bien choisir le moment du rapatriement en R (collect ou dbGetQuery). Globalement, plus ce moment vient tard, mieux c’est. Autrement dit plus on fait travailler Oracle au lieu de R, mieux c’est. C’est le même principe si on travaillait sur un autre moteur de base de données ou sur Spark. Ne jamais rapatrier des données de prestations (par exemple un bout de ER_PRS_F), cela va être très long tout en risquant de surcharger la mémoire vive du serveur, conduisant à un mail de la Cnam et l’arrêt de la session. On peut éventuellement rapatrier une table avec autant de lignes que d’individus, à condition de sélectionner peu de colonnes. Ensuite finir en R.

5.5 Traduire une commande dplyr en SQL Oracle

Dans les coulisses, le paquet dbplyr traduit le code type dplyr en SQL Oracle. Pour s’en convaincre, on peut montrer la requête effectivement exécutée avec show_query() ou remote_query()

tbl(conn, "IR_BIO_R") %>% show_query # du paquet dplyr

<SQL>
SELECT *
FROM "IR_BIO_R"

tbl(conn, "IR_BIO_R") %>% remote_query # du paquet dbplyr

<SQL> SELECT *
FROM "IR_BIO_R"

show_query affiche la commande sous la forme d’un message tandis que remote_query renvoie la commande sous la forme d’un résultat, ce qui peut permettre d’enregistrer le code de la requête comme on le verra plus bas.

show_query() et remote_query() peuvent être pratiques si l’on veut travailler directement avec le SQL Oracle (via dbGetQuery()) mais que l’on est rouillé. Ces commandes nous donnent la traduction SQL oubliée d’une commande dplyr que l’on connait.

Astuce : on peut montrer la traduction en même temps qu’on demande l’exécution de la requête en enchainant par de nouvelles commandes après show_query :

tbl(conn, "IR_BIO_R") %>%
  show_query  %>%
  head(1) %>%
  collect

<SQL>
SELECT *
FROM "IR_BIO_R"

5.6 Commandes dplyr non supportées

Toutes les commandes dplyr ne fonctionneront pas car le paquet dbplyr ne les traduit pas toutes.

Par exemple, la commande slice qui doit permettre de sélectionner une ligne par son numéro, ne peut pas être traduite :

# Ne fonctionne PAS sur une connexion à une base Oracle :
# tbl(conn, "IR_BIO_R") %>% slice(100)

# Alors qu'elle fonctionne sur un tableau déjà rappatrié en R :
tbl(conn, "IR_BIO_R") %>% collect %>% slice(100)

5.7 Fonctions courantes

Principalement des fonctions dbplyr.

5.7.1 Créer une colonne : mutate

On peut modifier une colonne ou la créer si elle n’existe pas encore.

Exemple sur le faux jeu : passer la colonne x au carré.

faux %>% mutate(x = x^2)

Créer une nouvelle colonne avec le carré de la colonne x.

faux %>% mutate(x2 = x^2)

Pour éviter les problèmes, respecter la casse ; si on crée une colonne sous le nom de “NoM”, il vaut mieux l’appeler par “NoM”. “nom” marchera dans certains cas (en SQL) et pas dans d’autres.

⚠ quelques raccourcis habituels en R ne fonctionnent plus

Par exemple, sur un objet R (ici rappatrié via collect), on peut créer une colonne avec une condition.

faux %>% collect %>% mutate(x2 = x > 2)

Sur une base Oracle (sans le collect), cela générera une erreur :

faux %>% mutate(x2 = x > 2) %>% show_query() %>% collect

<SQL>
SELECT "x", "y", "z", "x" > 2.0 AS "x2"
FROM ("PROV") 

Erreur dans .oci.SendQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00923: mot-clé FROM absent à l'emplacement prévu

Et il faudra expliciter avec ifelse, qui sera traduit par CASE WHEN en SQL :

faux %>% mutate(x2 = ifelse(x > 2, 1, 0)) %>% show_query() %>% collect # fonctionne

<SQL>
SELECT "x", "y", "z", CASE WHEN ("x" > 2.0) THEN (1.0) WHEN NOT("x" > 2.0) THEN (0.0) END AS "x2"
FROM ("PROV") 

5.7.1.1 Astuce : manipuler une colonne juste après sa création

On peut utiliser dans le même mutate une colonne qui vient d’être créée.

On crée une variable x3 qui dépend d’une variable x2 créée par la même occasion.

faux %>% mutate(x2 = x^2,
                x3 = x2 + 10)

5.7.2 Ordre : arrange

On peut ordonner avec arrange qui va créer un ORDER BY en SQL :

faux %>% arrange(-x) %>% show_query() %>% collect

<SQL>
SELECT *
FROM ("PROV") 
ORDER BY -"x"

-x permet d’obtenir un ordre décroissant tout comme desc(x).

5.7.3 Dédoublonnage : distinct

La fonction dbplyr distinct correspond à la fonction R base unique, elle élimine les lignes en doublons.

Exemple avec notre faux jeu de données.

faux %>% select(y) %>% distinct

5.7.4 Comptes : tally

tally permet de compter le nombre de lignes et va être traduit par un COUNT(*) en SQL :

mcoc <- tbl(conn, in_schema("MEPSGP_156", "ESND_T_MCO19C"))
mcoc %>%
  select("NIR_ANO_17") %>%
  distinct %>%
  tally %>%
  show_query %>%
  collect

<SQL>
SELECT COUNT(*) AS "n"
FROM (SELECT DISTINCT "NIR_ANO_17"
FROM ("MEPSGP_156"."ESND_T_MCO19C") ) "q01"

5.7.5 Groupages : group_by

tally fonctionne aussi avec group_by si l’on souhaite grouper par une variable.

Exemple on veut compter le nombre de séjours finis chaque mois de l’année 2019.

mcoc %>%
  group_by(EXE_SOI_AMF) %>%
  tally %>%
  show_query %>%
  collect

<SQL>
SELECT "EXE_SOI_AMF", COUNT(*) AS "n"
FROM ("MEPSGP_156"."ESND_T_MCO19C") 
GROUP BY "EXE_SOI_AMF"

count est un raccourci qui fait la même chose. Notez que c’est exactement la même traduction SQL :

mcoc %>%
  count(EXE_SOI_AMF) %>%
  show_query %>%
  collect

<SQL>
SELECT "EXE_SOI_AMF", COUNT(*) AS "n"
FROM ("MEPSGP_156"."ESND_T_MCO19C") 
GROUP BY "EXE_SOI_AMF"

5.7.6 Agrégations

tally est un raccourci pour summarise(n=n())

faux %>%
  group_by(y) %>%
  summarise(n = n()) %>% # au lieu de tally 
  show_query %>%
  collect

<SQL>
SELECT "y", COUNT(*) AS "n"
FROM ("PROV") 
GROUP BY "y"

On peut choisir d’agréger d’une autre manière, en prenant un compte unique, la moyenne, la somme, le max :

faux %>% summarise(n = n(),
                   n_unique = n_distinct(y),
                   moy = mean(x),
                   tot = sum(x),
                   max = max(x))

Parfois il est pratique d’ordonner et de prendre la première (first()) ou la dernière valeur (last()). Malheureusement, ces deux commandes ne fonctionnent qu’en tant que fonction de fenêtrage (avec mutate()) et non en fonction d’agrégation (avec summarize). Ainsi cette commande échoue :

faux %>% summarise(premiere = first(x))

Erreur : `first()` is only available in a windowed (`mutate()`) context

Une astuce consiste à coupler mutate() avec select() et distinct() :

faux %>%
  group_by(z) %>%
  mutate(premiere = first(x)) %>%
  select(z, premiere) %>%
  distinct

Mais il faut veiller à choisir les bonnes colonnes dans le select pour arriver au résultat escompté.

5.7.7 Fonctions de fenêtrage

5.7.7.1 Première observation

On peut utiliser group_by puis arrange (ou dans l’autre sens) pour ensuite créer une variable de rang ou filtrer directement sur le rang 1.

faux %>%
  arrange(-x) %>%
  group_by(y) %>%
  filter(row_number() == 1)

Avis : ORDER BY is ignored in subqueries without LIMIT
ℹ Do you need to move arrange() later in the pipeline or use window_order() instead?

On reçoit un avertissement ORDER BY is ignored in subqueries without LIMIT mais cela semble pourtant bien fonctionner, comme on peut le voir si on remplace -x par x puisque le résultat est cohérent. À manipuler avec précaution.

row_number accepte un argument d’ordre, ce qui permet de gagner en concision :

faux %>%
  group_by(y) %>%
  filter(row_number(-x) == 1)

Bémol : row_number n’accepte qu’une variable d’ordre, à la différence de arrange.

La fonction window_order() pourrait être la solution :

faux %>%
  group_by(y) %>%
  window_order(-x, z) %>%
  filter(row_number() == 1)

En plus le tibble garde les variables de groupage et d’ordre en attributs et les affiche, ce qui est pratique.

5.7.7.2 Agrégation par recyclage

L’agrégation par recyclage est un type particulier de fonction de fenêtrage. A la différence des fonctions d’agrégation, on garde le même nombre de lignes mais on réplique l’information au sein de chaque groupe. Il suffit de remplacer summarise() par mutate().

Exemple :

faux %>%
  group_by(z) %>%
  mutate(som = n_distinct(x))

5.7.7.3 Pour les amateurs

Pour des fonctions de fenêtrage plus complexes, on est obligés de passer par des méthodes plus proches de SQL. Un option est la fonction win_over qui aide à construire son fenêtrage.

faux %>%
  mutate(rang = dbplyr::win_over(con = conn, expr = sql("RANK()"), partition = "y", order = "x"))

Mais il n’est pas possible d’utiliser un ordre décroissant à ma connaissance.

Rien ne vaut le 100% SQL dans ce cas :

faux %>%
  mutate(rang = sql('RANK() OVER (PARTITION BY "y" ORDER BY "x" DESC)'))

5.7.8 Valeurs manquantes : NVL

On peut facilement remplacer les valeurs manquantes dans Oracle avec la fonction NVL (no value).

Exemple avec notre faux jeu de données.

faux %>%
  mutate(y2 = NVL(y, NA), # ne change rien
         y3 = NVL(y, 0)) # remplace par 0

# NVL(y, "A") ne fonctionne pas car y est de type numeric

# Exemple réel (commenté car résultats individuels)
# irbenr <- tbl(conn, "IR_BEN_R")
# irbenr %>%
#   select(IND_RNM_BEN) %>%
#   mutate(IND_RNM_BEN2 = NVL(IND_RNM_BEN, "NA")) # On peut mettre ce que l'on veut à la place de "NA"

5.7.9 Empiler des tables : union_all

Equivalent de la fonction R rbind :

union_all(faux, faux) %>% show_query() %>% collect

<SQL>
(SELECT *
FROM "PROV")
UNION ALL
(SELECT *
FROM "PROV")

5.7.10 Jointures

D’après le manuel de dbplyr, toutes les jointures possibles et leur équivalent en SQL :

• inner_join(x, y) : SELECT * FROM x JOIN y ON x.a = y.a
• left_join(x, y) : SELECT * FROM x LEFT JOIN y ON x.a = y.a
• right_join(x, y) : SELECT * FROM x RIGHT JOIN y ON x.a = y.a
• full_join(x, y) : SELECT * FROM x FULL JOIN y ON x.a = y.a
• semi_join(x, y) : SELECT * FROM x WHERE EXISTS (SELECT 1 FROM y WHERE x.a = y.a)
• anti_join(x, y) : SELECT * FROM x WHERE NOT EXISTS (SELECT 1 FROM y WHERE x.a = y.a)

Pour chercher plus de fonctions, le mieux est encore de consulter le manuel de dbplyr.

5.8 Utiliser SQL dans dplyr

Il est possible d’utiliser des commandes SQL directement dans la syntaxe dplyr lorsqu’un besoin n’est pas couvert par une commande dplyr.

Il y a trois manières de faire : avec des fonctions SQL, avec des opérateurs SQL, avec des bouts de code SQL.

5.8.1 Fonctions

Si une fonction n’est pas reconnue par R, elle va être laissée telle quelle pour Oracle, ce qui est très pratique. A vrai dire, c’était le cas de la fonction NVL présentée ci-dessus.

Exemple : la fonction CONCAT pour concaténer n’existe pas en R mais en Oracle :

tbl(conn, "T_MCO15C") %>% mutate(ano_retour = CONCAT(NIR_RET, NAI_RET)) %>% show_query

<SQL>
SELECT "EXE_SOI_AMD", "EXE_SOI_DTD", "EXE_SOI_AMF", "EXE_SOI_DTF", "COH_NAI_RET", "COH_SEX_RET", "DAT_RET", "ENT_DAT", "ETA_NUM", "FHO_RET", "FOR_NUM", "HOS_NNE_RET", "HOS_NN_MAM", "HOS_ORG_RET", "HOS_PLO", "NAI_RET", "NIR_ANO_17", "NIR_ANO_MAM", "NIR_RET", "NUM_DAT_AT", "NUM_DAT_AT_RET", "ORG_CPL_NUM_RET", "PMS_RET", "RNG_BEN", "RNG_BEN_RET", "RNG_NAI", "RNG_NAI_RET", "RSA_NUM", "SEJ_MER_RET", "SEJ_NUM", "SEJ_RET", "SEX_RET", "SOR_ANN", "SOR_DAT", "SOR_MOI", "VID_HOSP_FOR", CONCAT("NIR_RET", "NAI_RET") AS "ano_retour"
FROM ("T_MCO15C") 

L’inconvénient de ces fonctions est qu’elles ne s’auto-complètent pas en appuyant sur TAB et qu’on ne dispose pas d’une documentation intégrée. Il faut utiliser son navigateur pour les découvrir et apprendre à les utiliser. Exemple de documentation pour CONCAT.

5.8.2 Opérateurs

Si un opérateur entre % n’est pas reconnu par R, il va être laissé tel quel et Oracle pourra le comprendre.

Exemple sur un filtre classique pour retirer les séjours de MCO avec une erreur sur le NIR, on utilise %||% qui va devenir simplement || et qui permet la concaténation de plusieurs variables :

mcoc %>%
  mutate(ano_retour = NIR_RET %||% NAI_RET %||% SEX_RET %||%
  SEJ_RET %||% FHO_RET %||% PMS_RET %||% DAT_RET %||% COH_NAI_RET %||% COH_SEX_RET) %>%
  filter(ano_retour == "000000000") %>%
  tally %>%
  show_query %>%
  collect

<SQL>
SELECT COUNT(*) AS "n"
FROM (SELECT "EXE_SOI_AMD", "EXE_SOI_DTD", "EXE_SOI_AMF", "EXE_SOI_DTF", "COH_NAI_RET", "COH_SEX_RET", "DAT_RET", "ENT_ANN", "ENT_DAT", "ENT_MOI", "ETA_NUM", "ETA_NUM_RET", "FHO_RET", "FOR_NUM", "HOS_NNE_RET", "HOS_NN_MAM", "HOS_ORG_RET", "HOS_PLO", "ID_MAM_ENF", "IPP_BEN_ANO", "IPP_BEN_ANO_RET", "NAI_RET", "NIR_ANO_17", "NIR_RET", "NUM_DAT_AT", "NUM_DAT_AT_RET", "ORG_CPL_NUM", "ORG_CPL_NUM_RET", "PMS_RET", "RNG_BEN", "RNG_BEN_RET", "RNG_NAI", "RNG_NAI_RET", "RSA_NUM", "SEJ_MER_RET", "SEJ_NUM", "SEJ_RET", "SEX_RET", "SOR_DAT", "VID_HOSP_FOR", "NIR_RET" || "NAI_RET" || "SEX_RET" || "SEJ_RET" || "FHO_RET" || "PMS_RET" || "DAT_RET" || "COH_NAI_RET" || "COH_SEX_RET" AS "ano_retour"
FROM ("MEPSGP_156"."ESND_T_MCO19C") ) "q01"
WHERE ("ano_retour" = '000000000')

L’exemple le plus pratique est l’opérateur LIKE qui permet d’utiliser les expressions régulières (regex) Oracle pour décrire des chaînes de caractères complexes. Si on veut que PRS_NAT_REF commence par 31 :

erprsf %>% filter(PRS_NAT_REF %LIKE% "31%") %>% show_query

<SQL>
SELECT *
FROM (SELECT "BEN_NIR_PSA", "BEN_RNG_GEM", "BEN_SEX_COD", "BEN_AMA_COD", "BEN_RES_DPT", "BEN_RES_COM", "FLX_DIS_DTD", "EXE_SOI_AMD", "EXE_SOI_DTD", "PRS_NAT_REF", "PSE_ACT_NAT", "PSE_SPE_COD", "PRS_ACT_QTE"
FROM ("MEPSGP_156"."ESND_ER_PRS_F") 
WHERE ("FLX_DIS_DTD" - "EXE_SOI_DTD" < 183.0 AND "DPN_QLF" != 71.0 AND "PRS_DPN_QLP" != 71.0 AND "CPL_MAJ_TOP" < 2.0 AND "CPL_AFF_COD" != 16.0 AND (NOT("BEN_SEX_COD" IN ('0'))) AND "BEN_NAI_ANN" > 1800.0 AND "BEN_NAI_ANN" <= 2016.0)) "q01"
WHERE ("PRS_NAT_REF" LIKE '31%')

⚠ les regex Oracle ne fonctionnent pas de la même manière que les regex courantes sur Linux.

5.8.3 Bouts de code SQL

On peut toujours glisser des bouts de code SQL s’il n’y a quelque chose que l’on ne sait pas faire en syntaxe dplyr. Pour ça on utilisera la commande sql.

erprsf %>% filter(PSE_SPE_COD == sql("ANY (1,2,3)")) %>% show_query()

<SQL>
SELECT *
FROM (SELECT "BEN_NIR_PSA", "BEN_RNG_GEM", "BEN_SEX_COD", "BEN_AMA_COD", "BEN_RES_DPT", "BEN_RES_COM", "FLX_DIS_DTD", "EXE_SOI_AMD", "EXE_SOI_DTD", "PRS_NAT_REF", "PSE_ACT_NAT", "PSE_SPE_COD", "PRS_ACT_QTE"
FROM ("MEPSGP_156"."ESND_ER_PRS_F") 
WHERE ("FLX_DIS_DTD" - "EXE_SOI_DTD" < 183.0 AND "DPN_QLF" != 71.0 AND "PRS_DPN_QLP" != 71.0 AND "CPL_MAJ_TOP" < 2.0 AND "CPL_AFF_COD" != 16.0 AND (NOT("BEN_SEX_COD" IN ('0'))) AND "BEN_NAI_ANN" > 1800.0 AND "BEN_NAI_ANN" <= 2016.0)) "q01"
WHERE ("PSE_SPE_COD" = ANY (1,2,3))

Dans cet exemple, on aurait facilement pu remplacer la condition par PSE_SPE_COD %in% (1,2,3), mais dans quelques cas le SQL est la seule solution, en particulier pour les fonctions de fenêtrage.

Autre cas d’usage : pour éviter des ifelse imbriqués, on utilisera directement la fonction SQL CASE WHEN. Par exemple si on veut remplir BEN_RES_DPT2016_COMP avec le département au début 2016, BEN_RES_DPT2016, préalablement extrait. Lorsqu’il est absent on va chercher dans 2017 (BEN_RES_DPT2017), 2015, 2018, 2014, 2019, 2013, 2020. Si on a rien dans toutes ces années (pour un non consommant), on prend ces infos dans IR_BEN_R (BEN_RES_DPT).

# Ce code vient du projet beneficiairesSNDS (02_production.R), où il fonctionne
# irbenr4 %>%
#   mutate(BEN_RES_DPT2016_COMP = sql('CASE
#                                     WHEN NOT((("BEN_RES_DPT2016") IS NULL)) THEN ("BEN_RES_DPT2016")
#                                     WHEN NOT((("BEN_RES_DPT2017") IS NULL)) THEN ("BEN_RES_DPT2017")
#                                     WHEN NOT((("BEN_RES_DPT2015") IS NULL)) THEN ("BEN_RES_DPT2015")
#                                     WHEN NOT((("BEN_RES_DPT2018") IS NULL)) THEN ("BEN_RES_DPT2018")
#                                     WHEN NOT((("BEN_RES_DPT2019") IS NULL)) THEN ("BEN_RES_DPT2019")
#                                     WHEN NOT((("BEN_RES_DPT2013") IS NULL)) THEN ("BEN_RES_DPT2013")
#                                     WHEN NOT((("BEN_RES_DPT2020") IS NULL)) THEN ("BEN_RES_DPT2020")
#                                     ELSE "BEN_RES_DPT"
#                                     END')

5.9 Les dates

Pas vraiment facile à gérer. Le guide CNAM donne l’indication pour un filtre en utilisant la fonction Oracle TO_DATE :

irbior %>%
filter(BIO_CRE_DAT >= TO_DATE('2017-01-01','yyyy-MM-dd')) %>%
  head(5) %>%
  collect

⚠ il s’agit de dateHeure. Deux dates peuvent ne différer que de quelques heures. Le référentiel des bénéficiaires est un bon exemple quand on compare la date d’insertion dans le référentiel (BEN_DTE_INS) et la date de mise à jour (BEN_IDT_MAJ) :

irbenr <- tbl(conn, "IR_BEN_R")

irbenr %>%
  select(BEN_DTE_INS, BEN_IDT_MAJ) %>%
  filter(BEN_DTE_INS == TO_DATE('2020-03-11','yyyy-MM-dd')
        & BEN_IDT_MAJ < TO_DATE('2020-03-12','yyyy-MM-dd')
         ) %>%
  mutate(identiques = ifelse(BEN_DTE_INS == BEN_IDT_MAJ, 1, 0)) %>%
  head(5) %>%
  collect

Remarque 1 : il y a un problème de fuseau horaire à l’affichage des résultats (2020-03-10 23:00:00 et non 2020-03-11 00:00:00). Ce problème se trouve du côté de l’affichage en R et non du côté d’Oracle car le filtre a bien porté sur le 11 mars et non le 10.

Remarque 2 : pour ces lignes l’insertion et la mise à jour ont été faites le même jour mais à des heures différentes, d’où la colonne identiques à 0. Il faut donc être vigilant quand on compare des dates si l’on ne souhaite une précision qu’au jour près.

5.9.1 De dateHeure à date

Pour perdre le détail de l’heure, on peut utiliser la fonction SQL TRUNC :

irbenr %>%
  filter(BEN_DTE_INS == TO_DATE('2020-03-11','yyyy-MM-dd')
        & BEN_IDT_MAJ < TO_DATE('2020-03-12','yyyy-MM-dd')
         ) %>%
  select(BEN_IDT_MAJ) %>%
  mutate(BEN_IDT_MAJ_trunc = TRUNC(BEN_IDT_MAJ)) %>% # équivalent :
  # mutate(BEN_IDT_MAJ_trunc = sql("TRUNC(BEN_IDT_MAJ)")) %>%
  head(5) %>%
  collect

Pour une comparaison de deux dates, une autre solution aurait été de s’assurer que la valeur absolue de la différence est inférieure à 1 (abs(BEN_DTE_INS - BEN_IDT_MAJ)<1) mais cela ne revient pas exactement au même car on vérifie alors que moins de 24h se sont écoulées entre les deux dates et non qu’elles tombent sur le même jour.

5.9.2 Extraire le jour, le mois, l’année

Il faut de nouveau recourir à la fonction Oracle dédiée, EXTRACT :

res <- irbenr %>%
  select(BEN_DTE_INS) %>%
  filter(BEN_DTE_INS == TO_DATE('2020-03-11','yyyy-MM-dd')) %>%
  head(1) %>%
  mutate(ANNEE = sql("EXTRACT(YEAR FROM BEN_DTE_INS)"), MOIS = sql("EXTRACT(MONTH FROM BEN_DTE_INS)")) %>%
  collect()
res

On peut extraire les éléments suivants :

• YEAR
• MONTH
• DAY
• HOUR
• MINUTE
• SECOND
• TIMEZONE_HOUR
• TIMEZONE_MINUTE
• TIMEZONE_REGION
• TIMEZONE_ABBR

5.10 Analogie entre dbplyr et SparkR

Il y a une claire analogie entre SparkR et ROracle. Dans les deux cas R envoie des requêtes à un logiciel externe. Les paquets SparkR et ROracle font la traduction, Spark ou Oracle font le travail. Ensuite le résultat est rapatrié en R.

L’analogie va plus loin puisque SparkR a repris le vocabulaire de dplyr (select, filter…), ce qui est globalement assez pratique. Il y a quelques subtilités qu’on découvre par la pratique. Par exemple le head de dbplyr ne rapatrie pas en R à la différence de SparkR qui intègre un collect dans son head. Autre subtilité, les premières lignes sont toujours les mêmes avec Oracle, c’est-à-dire que deux head donnent le même résultat. En Spark les lignes ne sont pas vraiment ordonnées et deux head donnent des résultats différents.

En SparkR, il faut nommer les colonnes via donnees$colonne alors qu’on peut utiliser colonne en dbplyr.

En SparkR, on peut utiliser les fonctions temporelles pratiques year ou month que l’on ne trouve pas en ROracle où il faudra par exemple passer par sql("EXTRACT(YEAR FROM BEN_DCD_DTE)").

5.11 Un nom de variable variable

Lorsque l’on souhaite utiliser une variable au lieu du nom en dur d’une variable, on peut utiliser les opérateurs dplyr !! (bang-bang operator) et !!! (big bang operator), qui servent à pré-évaluer un objet.

Au lieu de

faux %>% summarize(moy = mean(x))

Je peux utiliser :

nomVariable <- "x"
faux %>% summarize(moy = mean(!!sym(nomVariable)))

Ce qui peut être pratique pour boucler sur des colonnes.

Une variante pour certains cas simples consiste à utiliser la fonction sql() qui injecte du code SQL (présentée ici):

nomVariable <- "Z"
faux %>%
  mutate(Z = z) %>% # contrainte supplémentaire :
  # sql va passer le code en majuscules, il faut donc des noms
  # de colonne en majuscules pour que ça fonctionne
  group_by(grp = sql(nomVariable)) %>% tally

Si vous êtes habitué à utiliser get() pour ce genre d’usages, cela ne fonctionnera pas ici car le get sera transmis à Oracle :

faux %>% summarize(moy = mean(get(nomVariable))) %>% show_query %>% collect

<SQL>
SELECT AVG(get('Z')) AS "moy"
FROM ("PROV") 

Erreur dans .oci.SendQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00904: "GET" : identificateur non valide

Exemple réel pour exporter les effectifs de chaque pathologie de la cartographie des pathologies en 2018 (30s).

ctind <- tbl(conn, in_schema("MEPSGP_156", "ESND_CT_IND_G8_2016"))

# Les variables qui nous intéressent commencent par le mot TOP ou SUP
tops <- colnames(ctind)[colnames(ctind) %like% "^(TOP|SUP)"]

# On va enregistrer les résultats dans une liste qu'on initie
liste <- list()

for (top in tops){
  print(top)
  prov <- ctind %>%
    filter(!!sym(top) == 1) %>% # technique pour avoir un nom de colonne variable
    tally %>%
    mutate(top = top) %>% # renommer la colonne avec le nom de la pathologie
    collect %>%
    setDT
  liste <- append(liste, list(prov)) # ajouter à la liste
}
tab <- rbindlist(liste) # empiler la liste
setcolorder(tab, "top") # réordonner les colonnes avec top en premier

# Ecriture pour export
# fwrite(tab, "~/EXPORT/effectifs_cartoPathos.csv")
tab[1:10,]

Pour déployer plusieurs variables dans une fonction, il faudra se tourner vers le big-bang operator, !!! :

variables <- c("x", "z")
faux %>% select(!!!variables)

5.12 Forcer l’évaluation en R

La ligne de partage entre ce qui est évalué en R et ce qui est évalué en SQL est ténue. La preuve par l’exemple : dans la commande suivante id est bien remplacé par sa valeur, tout fonctionne :

id <- 3
faux %>% filter(x == id)

Alors que si on cherche à prendre un élément dans un vecteur, il fait une traduction SQL étrange avec un CASE WHEN qui génère une erreur :

ids <- 3:4
faux %>% filter(x == ids[1]) %>% show_query %>% collect

<SQL>
SELECT *
FROM ("PROV") 
WHERE ("x" = CASE WHEN (1.0) THEN ((3, 4)) END)

Erreur dans .oci.SendQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00920: opérateur relationnel non valide

La pré-évaluation par l’opérateur bang-bang !! nous sortira de ce mauvais pas :

ids <- 3:4
faux %>% filter(x == !!ids[1]) %>% show_query %>% collect

<SQL>
SELECT *
FROM ("PROV") 
WHERE ("x" = 3)

Cela vaut aussi pour des fonctions qui générerait du code SQL :

contenuSQL <- function() sql('POWER("x", 2.0)')
faux %>% mutate(x2 = contenuSQL()) # ERREUR

Erreur dans .oci.SendQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00904: "CONTENUSQL" : identificateur non valide

faux %>% mutate(x2 = !!contenuSQL()) # FONCTIONNE

6 Tables et vues

Il n’y a pas de manière graphique pour naviguer dans les tables disponibles comme sur SAS. Si on connait le nom de la table, on l’appelle directement. Sinon, pour retrouver une table, on peut toujours aller chercher son nom dans SAS. Si l’on ne souhaite pas lancer SAS, on peut toujours utiliser les commandes ci-dessous.

N.B. : la plupart des noms de tables que l’on connaît ne renvoient pas vraiment à des tables mais à des vues, c’est-à-dire des enregistrements de requêtes, ou à des synonymes, c’est-à-dire des surnoms.

6.1 Lister les tables publiques

Dans une base Oracle, il existe des tables spéciales qui listent les objets :

• all_tables liste les tables ;
• all_views liste les vues ;
• all_synonyms les synonymes ;
• all_objects tous les objets (tables, vues, synonymes, index, séquences, éditions, paquets…).

Je déconseille le chargement en mémoire d’une de ses tables, assez long. Par exemple, la table all_tables se charge en 15 minutes alors que la plupart des objets qui nous intéressent (des vues et des synonymes) en sont absents.

Mieux vaut faire la recherche directement en Oracle sur la table all_objects. Imaginons que l’on cherche tous les objets qui contiennent CT_IND pour la table centrale de la cartographie des pathologies.

system.time({
  tables <- dbGetQuery(conn,
  "SELECT owner, object_name, object_id, object_type, created FROM all_objects WHERE object_name LIKE '%CT_IND%'")
  # '%CT_IND%' est une expression régulière Oracle où % est remplacé par autant de caractères que nécessaire
  }) # 8 secondes

utilisateur     système      écoulé 
      0.004       0.001       3.117 

tables$OWNER <- nettoy(tables$OWNER) # retrait de l'identifiant utilisateur
tables[, c("OWNER", "OBJECT_NAME", "OBJECT_TYPE")]

Certes avec R, nous n’avons pas l’arborescence comme dans SAS pour chercher les tables mais cela est aussi un atout. Par exemple ici j’ai pu lister toutes les tables relatives à la cartographie alors que les anciennes versions se trouvent dans ORAVUE et les nouvelles dans ORAMEPS. Sur SAS, il faut savoir où chercher pour dérouler la bonne bibliothèque.

On découvre aussi le type de l’objet et on peut ajouter sa date de création (created).

6.2 Lister les tables privées

Pour lister les tables de l’utilisateur, il suffit d’utiliser user_tables au lieu de all_tables. En l’occurrence, il s’agira normalement de tables et non de vues et synonymes donc il n’est pas nécessaire d’utiliser user_objects.

system.time({user_tables <- dbGetQuery(conn, "SELECT TABLE_NAME FROM user_tables")}) # 2

utilisateur     système      écoulé 
      0.002       0.001       2.581 

if (nrow(user_tables) == 1) {
  user_tables
} else {
  warning("Il y a d'autres tables que le faux jeu de données, on affiche rien.")
}

Avis : Il y a d'autres tables que le faux jeu de données, on affiche rien.

Les tables listées ici se trouvent dans la bibliothèque ORAUSER sur SAS. On retrouve bien la table PROV qui est notre faux jeu de données.

6.3 Charger une table d’un autre schéma

En Oracle, un schéma est un ensemble d’objets d’une base de données. Un schéma correspond à un propriétaire (owner) et a le même nom que lui. Est-ce utile de savoir cela ? Oui car si vous voulez travailler sur l’ESND, vous allez avoir un problème :

tbl(conn, "ESND_ER_PRS_F")

Erreur dans .oci.GetQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00942: Table ou vue inexistante

La vue n’est pas trouvée. On vérifie qu’elle existe bien :

tables <- dbGetQuery(conn, "SELECT owner, object_name, object_type FROM all_objects WHERE object_name LIKE '%ESND_ER_PRS%'")
tables$OWNER <- nettoy(tables$OWNER) # retrait de l'identifiant utilisateur
tables

Elle existe mais elle appartient au schéma/propriétaire MEPSGP_156 (dans le cas du profil 156), qui diffère du schéma ADGPP de ER_PRS_F. Le schéma de ER_PRS_Fdoit être celui par défaut de telle sorte que tbl(conn, "ER_PRS_F") fonctionne alors que tbl(conn, "ESND_ER_PRS_F") ne fonctionne pas. On peut préciser un schéma différent du schéma par défaut grâce à in_schema() :

# erprsf <- tbl(conn, in_schema("PREGP_156", "ESND_ER_PRS_F")) # ne fonctionne pas
erprsf <- tbl(conn, in_schema("MEPSGP_156", "ESND_ER_PRS_F")) # fonctionne

6.4 Les bibliothèques SAS

Les tables SAS ne sont pas accessibles. Sur SAS elles portent un pictogramme de loupe.

Pour les ramener dans Oracle (dans Orauser) et ainsi pouvoir les manipuler avec ROracle, il faut exécuter une requête sur SAS.

Par exemple si l’on veut récupérer la table EXTRACTION_PATIENTS2019TR de consopat :

# Code optimisé qui vient du GUIDE DES BONNES PRATIQUES SAS - v2.0.pdf
proc sql;
    drop table orauser.tableoracle;
    create table orauser.tableoracle (BULKLOAD=yes BL_DATAFILE="%sysfunc(pathname(work))/ttt.xyz" BL_DELETE_DATAFILE=yes) as select * from CONSOPAT.EXTRACTION_PATIENTS2019TR;
quit;

Il y a un fort intérêt à sélectionner quelques variables au lieu de select * pour accélerer l’exécution et réduire la place prise sur ORAUSER.

Une autre solution consiste à charger les tables SAS avec le paquet haven. Cela fonctionne avec les vraies tables :

haven::read_sas("~/consopat/es_mts_v.sas7bdat")[1:4,]

Mais pas avec les vues SAS (.sas7bvew) :

haven::read_sas("~/consopat/extraction_patients2021tr.sas7bvew")

Erreur : Failed to parse /sasdata/prd/commun/data/consopat/extraction_patients2021tr.sas7bvew: Invalid file, or file has unsupported features.

Pas de solution apparente (voir cette discussion sur Stackoverflow), il faut recourir au rapatriement en SAS sur Orauser.

6.5 Sauvegarder une table intermédiaire

Il faut bien distinguer les tableaux R des pointeurs vers les tables Oracle :

a <- tbl(conn, "IR_BIO_R") # a est un pointeur vers la table Oracle
a <- tbl(conn, "IR_BIO_R") %>% collect # a est une table R

Si on possède une table R, on peut suivre le guide de la Cnam pour l’enregistrer sous Oracle avec :

# On supprime la table si elle existe déjà, sinon erreur
try(dbRemoveTable(conn, "PROV"), silent = T) # le nom doit être en majuscule

# Ecriture à proprement parler
dbWriteTable(conn, "PROV", faux0) # faux0 est un data.frame

Mais cela implique un collect auparavant. Le circuit est alors Oracle > R > Oracle ce qui est sous-optimal puisque le collect est une opération coûteuse. Une meilleure solution est de ne pas rapatrier l’objet en R, de tout faire en Oracle.

Théoriquement la fonction dbplyr compute réalise cela et doit être très pratique :

# ERREUR A CE JOUR
# a <- tbl(conn, "IR_PHA_R") %>%
#   filter(PHA_ATC_C03 == "A10") %>% # Médicaments du diabète
#   compute

Elle doit enregistrer le résultat du calcul en tant que table Oracle et la relire pour faire de a un pointeur. Cela permettrait donc de faire un point d’arrêt qui évite de reprendre tous les calculs depuis le début.

Hélas la fonction compute ne marche pas avec une base Oracle pour l’instant car la traduction oublie le mot clé GLOBAL dans la requête. Le bug concerne aussi la fonction copy_to, qui fait le contraire du collect, c’est-à-dire envoyer à Oracle un objet R. J’ai enregistré un ticket sur le Github du projet dbplyr, le bug a été traité et le compute devrait bientôt de nouveau fonctionner.

En attendant je propose cette fonction artisanale qui fait la même chose et je la couple avec une fonction de nettoyage pour supprimer les tables provisoires de temps en temps :

# Supprimer des tables :
# - lesquelles = "prov" : les tables provisoires
# - lesquelles = "provRecentes" : les tables provisoires avant aujourd'hui
# - lesquelles = "toutes" : toutes les tables de l'utilisateur
supprTables <- function(lesquelles = "provRecentes"){
  vect0 <- dbGetQuery(conn, "SELECT TABLE_NAME FROM user_tables")$TABLE_NAME
  
  # On filtre les tables provisoires 
  vect1 <- vect0[grepl("PROV[0-9]{14}", vect0, perl = T)]
  
  vect2 <- gsub("PROV([0-9]{14})", "\\1", vect1, perl = T)
  vect2 <- as.Date(vect2, "%Y%m%d")
  
  if (lesquelles == "toutes") {
    vectAsupp <- vect0
  } else if (lesquelles == "prov"){
    vectAsupp <- vect1
  } else {
    vectAsupp <- vect1[vect2 < Sys.Date()]
  }
  
  if (length(vectAsupp)) sprintf("Tables supprimées : %s", paste(vectAsupp, collapse = ", "))
  
  for (nomTable in vectAsupp) {
    try(dbRemoveTable(conn, nomTable), silent = T)
  }
}

# Equivalent fonctionnel de la fonction compute()
compute2 <- function(tbl_oracle) {
  # On commence par un nettoyage des anciennes tables provisoires
  # si on a oublié de le faire
  supprTables(lesquelles = "provRecentes")
  
  # On choisir un nom daté pour enregistrer la table
  nomTable <-  paste0("PROV", format(Sys.time(), "%Y%m%d%H%M%S"))
  
  # renvoie une erreur si la table n'existe pas
  system.time({
  #
  dbExecute(conn, paste0("CREATE TABLE ", nomTable," AS (", remote_query(tbl_oracle), ")"))
  })
  tbl(conn, nomTable)
}

Exemple d’utilisation

# Longs calculs (ici courts pour l'exemple)
a <- tbl(conn, "IR_PHA_R") %>%
  filter(PHA_ATC_C03 == "A10")

# On écrit une table intermédiaire
a <- compute2(a)

Preuve que a est un pointeur vers une table intermédiaire et non une suite d’instructions :

a %>% show_query

<SQL>
SELECT *
FROM "PROV20230213145207"

Pour nettoyer les tables intermédiaires écrites, portant le nom de “PROV”, vous pouvez exécuter de temps en temps la fonction supprTables :

supprTables(lesquelles = "prov")

Après nettoyage, le pointeur a est cassé :

a # "ORA-00942: Table ou vue inexistante"

Erreur dans .oci.SendQuery(conn, statement, data = data, prefetch = prefetch,  : 
  ORA-00942: Table ou vue inexistante

6.6 Orauser

Que ce soit via dbWriteTable(conn, "nomTABLE", unDataFrameR) ou la fonction ci-dessus compute2, on écrit sur l’espace Orauser, qui est un espace partagé. Contrairement à SASDATA1, il n’y a pas de quotas individuels. L’espace est quand même contraint et la Cnam envoie régulièrement des mails pour faire supprimer des tables et éviter la saturation de l’espace partagé. La bonne pratique est de supprimer ses tables dès que possible. Le nettoyage peut se faire de façon visuelle sur SAS ou avec la fonction supprTables définie ci-dessus.

7 Gérer sa session RStudio

7.1 Que faire en cas de perte de contrôle ?

Arrêter une requête en cours d’exécution n’est pas une chose simple. Souvent le bouton rouge Stop ne fonctionne pas car cela envoie un signal d’arrêt à la commande R et non à la requête Oracle.

On peut toujours essayer mais si ça ne fonctionne pas, la meilleure solution est de forcer l’arrêt de la session :

1. sélectionner le code s’il n’est pas enregistré, le copier-coller quelque part, en sécurité ;
2. cliquer sur le gros R bleu en haut à gauche pour rejoindre le menu ;
3. cocher la session en question ;
4. sélectionner “force quit” ;
5. réouvrir une session / le projet ;
6. reprendre son code non-enregistré.

Si l’étape 2 est impossible car le gros R bleu n’est pas visible, vous pouvez directement copier-coller l’URL https://rstudio-prod.local/R/ dans le navigateur chromium (celui ouvert pour R).

7.2 Coupures

Lors des pauses, Citrix peut se déconnecter ce qui ferme RStudio. Néanmoins les calculs en cours ne sont pas arrêtés, même en pleine nuit, à la différence de SAS qui est redémarré à 2h. Lorsqu’on lance à nouveau “RStudio Workbench” depuis le portail, la session s’ouvre dans le même état qu’on l’a laissée, avec tous les objets chargés. Attention, si la session compte de gros objets, l’ouverture de la session peut être long. Il est conseillé autant que possible de fermer sa session lorsqu’on a fini de travailler et d’en ouvrir une nouvelle. Cela libère de la mémoire tout en garantissant la réplicabilité de ses résultats.

Lorsqu’une session est inactive depuis trop longtemps, elle peut être supprimée automatiquement. Il est plus prudent de ne jamais compter sur les objets R de la session.

7.3 Copier-coller

Depuis la mise en production de l’interface RStudio, le collage depuis le presse-papier échoue parfois. Lorsqu’on copie depuis RStudio et qu’on colle dans RStudio, aucun problème. Lorsqu’on copie un bout de code hors de RStudio et qu’on le colle dans RStudio, cela échoue si l’on avait déjà sélectionné un bout de texte que l’on comptait remplacer. Il faut donc supprimer le texte avant, puis copier le contenu et le coller ensuite sans avoir sélectionné de texte. Attention cela échoue si on inverse l’ordre des opérations (par exemple : copier-supprimer le texte-coller).

8 Git

Logiquement, il n’est pas possible de connecter son projet à un dépôt Git sur Github ou Gitlab puisqu’il s’agit d’une bulle sécurisée. Cela n’empêche pas l’utilisation de Git en local. Ça ne permet pas de travailler à plusieurs sur le même code (quoi que ça s’envisage avec un espace projet) mais cela permet tout de même de faire le versionnage de son code tout en le sécurisant.

Pour initialiser un dossier Git : File > New project > New Directory > New Project puis choisir un nom de projet, un emplacement et cocher Create a git repository. Enfin valider avec Create project as subdirectory.

Ensuite on peut utiliser Git normalement à partir du panneau en haut à droite. Si l’on veut faire certaines opérations non incluses dans le panneau, on peut toujours utiliser la commande system pour lancer une commande système.

Quelques exemples :

system(
  # Décommenter la ligne intéressante
  
  # Configurer son nom
  # "git config --global user.name 'Samuel Allain'"
  # Vérifier
  # "git config --global user.name"
   
  # Configurer son adresse mail
  # "git config --global user.email 'samuel.allain@sante.gouv.fr'"
  # Vérifier
   # "git config --global user.email"
   
  # Etat du dépôt
  # "git status"
  
  # Ajouter une étiquette
  # "git tag v0.2"
  
  # Supprimer une étiquette
  # "git tag -d v0.2"
  
  # Version de Git
  "git --version"
)

git version 1.8.3.1

Bémol : lors de la pseudonymisation, il est difficile de gérer l’historique Git, constitué d’une foule de fichiers dans le dossier .git. En effet l’utilitaire fourni par la Cnam, BRUS, demande de valider chaque fichier, un à un.

9 Configuration RStudio

9.1 Dictionnaire français pour la correction orthographique

Le dictionnaire français n’est pas présent par défaut. Il n’est pas possible de le télécharger directement en utilisant Tools > Global Options > Spelling > Main dictionary language > Install more language car RStudio est coupé du reste d’internet. On peut en revanche récupérer l’URL indiquée par l’erreur :

https://s3.amazonaws.com/rstudio-buildtools/dictionaries/all-dictionaries.zip

Puis télécharger le zip, le décompresser, et importer les fichiers fr_FR.dic (dictionnaire) et fr_FR.aff (affixes pour les accords etc.) dans son Home. Une fois cela fait, il faut déplacer les fichiers au bon endroit, ce que devraient faire ces commandes :

# On crée le dossier pour accueillir les fichiers de dictionnaires
system("mkdir -p ~/.config/rstudio/dictionaries/languages-system")

# Copier les fichiers dans ce nouveau dossier
system("cp ~/fr_FR.dic ~/.config/rstudio/dictionaries/languages-system")
system("cp ~/fr_FR.aff ~/.config/rstudio/dictionaries/languages-system")

Ensuite redémarrer RStudio (Session > Terminate R) pour prendre en compte les changements. Vérifier dans Tools > Global Options > Spelling que la manipulation a fonctionné (“French”).