preparation_note_blog.qmd

---
title: Guide d'utilisation des données du recensement de la population au format `Parquet`
#jupyter: python3
#embed-resources: true
code-annotations: true
date: 2023-10-18
bibliography: reference.bib
toc: true
format:
  html: default
---

Ce guide présente quelques exemples d'utilisation des données du 
recensement de la population diffusées au format `Parquet`. 
Il s'agit d'une version HTML
enrichissant le guide publié sur le site [insee.fr](https://www.insee.fr/fr/statistiques/7637890)
pour les langages `Python` {{< fa brands python >}} et {{< fa brands r-project >}} avec
des exemples interactifs pouvant être
construits par le biais de `Quarto Markdown` et `Observable`.

L'ensemble des codes utilisés pour produire cette note
est disponible sur le
dépôt [`Github` {{< fa brands github >}} InseeFrLab/exemples-recensement-parquet](https://github.com/InseeFrLab/exemples-recensement-parquet)
au format [`Quarto Markdown`](https://quarto.org/).

Pour plus d'informations sur le format `Parquet`, dans un contexte
de statistique publique, se référer à @dondon-lamarche-2023. Pour
un exemple sur la différence entre format `CSV` et `Parquet`
illustré sur les données du recensement de la population, voir @mauviere-2022.

Ce guide propose d'utiliser [`DuckDB`](https://duckdb.org/) à travers
plusieurs langages pour effectuer des traitements sur les fichiers
détails du recensement.
Par rapport à d'autres approches, [`DuckDB`](https://duckdb.org/) a été choisi pour son efficacité ainsi que pour son universalité[^notealternative].

[^notealternative]: Des propositions d'enrichissements de cette documentation à partir d'implémentations alternatives, par exemple s'appuyant sur `Arrow` et `dbplyr` ou sur `Polars` sont bienvenues sur le [Github InseeFrLab/exemples-recensement-parquet](https://github.com/InseeFrLab/exemples-recensement-parquet).


<details>
<summary>Afficher le dictionnaire des variables</summary>

Il est possible de rechercher
dans la documentation des noms de variables ou des informations dans les descriptions. 
Lorsqu'une variable présente de nombreuses modalités, seules la première est la dernière
sont
retournées. Un exemple ci-dessous montre comment utiliser une requête SQL pour
récupérer l'ensemble des valeurs d'une telle variable. 


```{ojs}
//| echo: false
viewof unique_description_filter = Inputs.search(
  documentation_indiv, {
    placeholder: "Trouver une information dans la documentation"
  }
  )
```

```{ojs}
//| echo: false
table_filtre_description = Inputs.table(
  unique_description_filter,
  {
    header: {
      description_variable: "Description de la variable"
    }    
  }
)
```

```{ojs}
//| echo: false
documentation_indiv = db.query(`SELECT * FROM documentation_indiv`)
```


</details>

::: {.callout-note}
Ce _post_ accompagne la mise à disposition des données
du recensement de la population au format `Parquet`
sur le site [insee.fr](https://www.insee.fr/fr/statistiques/7706119?sommaire=7637890).

Il vise à fournir
une expérience plus ergonomique et des exemples supplémentaires liés
au langage `Javascript` au guide PDF disponible sur la page du site
[insee.fr](https://www.insee.fr/fr/statistiques/7706119?sommaire=7637890).

⚠️ Cette page s'appuie sur l'exploitation de données qui sont préalablement
téléchargées de manière automatique par le navigateur _web_. 
Celles-ci représentent une volumétrie autour de 1Go, ce qui peut nécessiter
un certain temps en fonction de la bande passante. Une fois téléchargées,
l'exploitation
de ces données nécessite néanmoins beaucoup moins de ressources
grâce à l'optimisation permise par `DuckDB`. 
:::


# Initialisation

Les données sont disponibles sur le site `data.gouv` aux adresses suivantes :

* [Fichier détail individuel](https://www.insee.fr/fr/statistiques/7706119?sommaire=7637890) ;
* [Fichier détail logement](https://www.insee.fr/fr/statistiques/7705908?sommaire=7637890).


Dans la suite de ce guide, il sera fait l'hypothèse 
pour `Python` et `R`
que les données sont récupérées depuis les URL stables,
enregistrées dans un même dossier
et qu'il existe une variable _ad hoc_ enregistrant ce chemin 
dans `Python` ou `R`. 
En ce qui concerne `Observable`, il est proposé
d'utiliser directement l'URL de mise à disposition
des fichiers. 


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

Les URL stables de mise à dispositon des
données seront directement renseignées dans 
la création de la base de données. 


::: {.callout-caution collapse="true"}

## Emplacement des données pour les exemples `Observable` 

En ce qui concerne `Observable`, il est proposé
d'utiliser directement l'URL de mise à disposition
des fichiers car l'extension `httpfs` 
est nativement intégrée à la librairie `DuckDB`, 
_a contrario_ des clients `Python` et `R`.

Ces jeux de données sont automatiquement téléchargés par le
navigateur et mis en _cache_ pour accélérer des utilisations
ultérieures de la page. Le premier chargement de tous
les tableaux et graphiques sur celle-ci
peut ainsi prendre un peu plus de temps. 

:::

## `Python` {.unnumbered .unlisted}

```python
path_data = 'C:/MesDocuments/dossierpersonnel'
# remplacer par l'emplacement où sont stockées 
# les données
```

## `R` {.unnumbered .unlisted}

```r
path_data <- 'C:/MesDocuments/dossierpersonnel'
# remplacer par l'emplacement où sont stockées 
# les données
```

## `R (dbplyr)` {.unnumbered .unlisted} 

```r
path_data <- 'C:/MesDocuments/dossierpersonnel'
# remplacer par l'emplacement où sont stockées 
# les données
```

:::

Il est proposé, pour initialiser la connexion entre
les données `Parquet` et le langage
client (`Javascript`, `R` ou `Python`)
d'utiliser des vues. Ceci permet de faire référence de manière
répétée à la même source de données par le biais d'un
alias (`table_logement` ou `table_individu`).


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

<details>
<summary>
Dérouler pour découvrir le code <code>Observable</code> d'initialisation de la base de
données avec <code>DuckDB</code>
</summary>
{{< include snippets/1_create_db_ojs.qmd >}}
</details>

## `Python` {.unnumbered .unlisted}

{{< include snippets/1_create_db_python_md.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/1_create_db_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/1_create_db_r_dbplyr.qmd >}}
:::

Pour rapidement avoir une idée des informations présentes dans ces données,
le code ci-dessous peut être utilisé :



::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/2_select_schema_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/2_select_schema_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/2_select_schema_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/2_select_schema_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
schema_table_individu = db.query(
  "SELECT * FROM documentation_indiv"
  )
Inputs.table(schema_table_individu)
```


Pour découvrir les informations présentes dans la base,
il est possible d'utiliser les fonctions pré-implémentées
de `DuckDB` pour la [manipulation de données textuelles](https://duckdb.org/docs/sql/functions/char.html).
Par exemple, pour 
extraire toutes les modalités des variables dont la description contient le terme _"catégorie"_ :


::: {.panel-tabset group="language"}


## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/3_select_documentation_ojs.qmd >}}


## `Python` {.unnumbered .unlisted}

{{< include snippets/3_select_documentation_python.qmd >}}


## `R` {.unnumbered .unlisted} 

{{< include snippets/3_select_documentation_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/3_select_documentation_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
query = "SELECT * FROM documentation_logement WHERE CONTAINS(description_variable, 'Catégorie')"
Inputs.table(
    db.query(query)
)
```

Cette approche peut permettre de récupérer les modalités d'une variable.
Dans cette base de données, les valeurs `Z` sont à part.
Il est possible d'avoir du détail sur celles-ci avec la requête suivante :


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/4_selectz_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/4_selectz_python.qmd >}}


## `R` {.unnumbered .unlisted} 

{{< include snippets/4_selectz_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/4_selectz_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
  db.query(
    "SELECT * FROM documentation_indiv WHERE CONTAINS(code_modalite, 'Z')"
  ),
  {
    columns: [
      "nom_variable","code_modalite",
      "description_modalite", "description_variable",
      "type_variable"
      ]
  }
)
```

# Lecture et affichage de quelques valeurs

Pour visualiser un nombre limité de valeurs, par exemple 5,
deux approches sont possibles :

- Sélectionner un échantillon restreint sur les premières lignes du `Parquet`, par exemple les 5 premières lignes ;
- Sélectionner un échantillon aléatoire.

Pour les premières lignes, la commande à utiliser est `LIMIT`.


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/5_limit_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/5_limit_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/5_limit_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/5_limit_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT * FROM table_logement LIMIT 5")
)
```

Pour un échantillon aléatoire, la commande à utiliser est `USING SAMPLE`.

```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT * FROM table_logement USIN SAMPLE 5")
)
```


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/5_sample_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/5_sample_python.qmd >}}


## `R` {.unnumbered .unlisted} 

{{< include snippets/5_sample_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/5_sample_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT * FROM table_logement USING SAMPLE 5")
)
```

# Sélectionner des observations ou des variables

## Requêtes sur les colonnes (`SELECT`)

La liste des colonnes à extraire du fichier peut être renseignée avec la clause `SELECT`.
Celles-ci peuvent être renommées en appliquant au passage la clause `AS`.


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/6_sample_columns_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/6_sample_columns_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/6_sample_columns_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/6_sample_columns_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT IPONDI AS poids, AGED, VOIT FROM table_individu LIMIT 10")
)
```

`DuckDB` propose également des fonctionnalités pour extraire
des colonnes à travers des [expressions régulières](https://fr.wikipedia.org/wiki/Expression_r%C3%A9guli%C3%A8re). 
De nombreux exemples peuvent être trouvés sur [cette page](https://duckdb.org/2023/08/23/even-friendlier-sql.html).


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/7_use_regex_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/7_use_regex_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/7_use_regex_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/7_use_regex_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT IPONDI AS poids, COLUMNS('.*AGE.*') FROM table_individu LIMIT 10")
)
```

## Requêtes sur les lignes (`WHERE`)

Pour extraire un sous-échantillon des données complètes, la clause
`WHERE` permet d'appliquer des filtres à partir de conditions
logiques. 
Par exemple, il est possible de ne conserver, du fichier national, que les données de l'Aude (11), 
de la Haute-Garonne (31) et de l'Hérault (34). 


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/8_filter_dpts_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/8_filter_dpts_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/8_filter_dpts_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/8_filter_dpts_r_dbplyr.qmd >}}


:::


```{ojs}
//| echo: false
Inputs.table(
    db.query("SELECT * FROM table_individu WHERE DEPT IN ('11', '31', '34') LIMIT 10")
)
```


Il est également possible de formater cette liste telle qu'attendue par SQL 
à partir d'une liste `Python` ou d'un vecteur `R` plus classique.
Pour cela, le code suivant peut servir de modèle :


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/8_filter_regions_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/8_filter_regions_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/8_filter_regions_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/8_filter_regions_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
liste_regions = ["11", "31", "34"]
liste_regions_sql = liste_regions.map(item => `'${item}'`).join(",")
Inputs.table(
    db.query(`SELECT * FROM table_individu WHERE DEPT IN (${liste_regions_sql}) LIMIT 10`)
)
```

Pour en savoir plus sur les _prepared statements_ avec DuckDB en Python,
et plus généralement pour avoir des exemples d'utilisations différentes,
c'est [ici](https://duckdb.org/docs/api/python/dbapi.html) que ça se passe.

<br>

Les filtres sur les observations peuvent être faits à partir de critères
sur plusieurs colonnes. Par exemple, pour ne conserver que les observations
de la ville de Nice où la date d'emménagement est postérieure à 2020, 
la requête suivante peut être utilisée :


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/8_filter_dates_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/8_filter_dates_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/8_filter_dates_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/8_filter_dates_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
    db.query(
        "SELECT * FROM table_logement WHERE COMMUNE = '06088' and AEMM > 2020"
    )
)
```

# Statistiques agrégées

Le langage `SQL` permet d'exécuter de manière très efficace
des requêtes complexes afin de construire, à partir de 
données fines, des statistiques agrégées. 

Cette partie illustre d'abord ceci avec deux exemples de statistiques agrégées renvoyant une unique statistique :

- Extraire la liste des codes arrondissements de Paris, Lyon, Marseille où au moins une personne a été recensée ;
- Reproduire l'exemple de @mauviere-2022 permettant de calculer le nombre d'habitants de Toulouse qui ont changé de logement en un an ; 

Ensuite, des statistiques plus fines sont construites par le biais
d'agrégations par groupe :

- Calculer le nombre de personnes recensées par cohorte pour
les départements de l'Aude (11), de la Haute-Garonne (31) et
de l'Hérault (34) ; 
- Calculer le nombre de centenaires recensés par département.

La fonction
`DISTINCT` appliquée à la variable `ARM` 
permet d'extraire la liste des codes arrondissements
présents dans la base de données.


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/9_distinct_arrondissements_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/9_distinct_arrondissements_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/9_distinct_arrondissements_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/9_distinct_arrondissements_r_dbplyr.qmd >}}


:::

```{ojs}
//| echo: false
Inputs.table(
    db.query(
        "SELECT DISTINCT(ARM) FROM table_logement WHERE NOT CONTAINS(ARM, 'ZZZZZ') ORDER BY ARM"
    )
)
```

Il est possible d'extraire des statistiques beaucoup plus raffinées
par le biais d'une requête SQL plus complexe. Par exemple pour calculer
le nombre d'habitants de Toulouse qui ont changé de logement en un an:


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/10_use_cast_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/10_use_cast_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/10_use_cast_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/10_use_cast_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
  db.query(
    `
    SELECT CAST(
      SUM(IPONDL*CAST(INPER AS INT)) AS INT
    ) AS habitants_toulouse_demenagement
    FROM table_logement
    WHERE COMMUNE == '31555' AND IRANM NOT IN ('1', 'Z') AND INPER != 'Y'
    `
  )
)
```

Pour représenter la pyramide des âges recensés
dans ces trois départements, il est possible
de procéder en deux étapes

- Effectuer une agrégation par le biais de `DuckDB`
et transformer ces résultats sous forme de _dataframe_
- Utiliser ce _dataframe_ avec un _package_ d'analyse
graphique pour représenter la pyramide des âges.


::: {.callout-note}
Pour illustrer le parallélisme possible entre les codes
`R` et `Python`, l'exemple de représentation graphique ci-dessus s'appuie sur
le _package_ `plotnine` - 
dont la syntaxe reproduit celle du _package_ `R` `ggplot2`, plutôt que sur
`matplotlib` ou `seaborn`. 
:::


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/11_pyramide_ages_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/11_pyramide_ages_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/11_pyramide_ages_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/11_pyramide_ages_r_dbplyr.qmd >}}

:::

Pour utiliser une version compatible, par exemple la `0.6.11`, faire:

```{ojs}
//| echo: false
Plot = require("https://cdn.jsdelivr.net/npm/@observablehq/plot@0.6.11/dist/plot.umd.min.js")
```


```{ojs}
//| echo: false
pyramide_ages = db.query(
`
SELECT
  CAST(SUM(IPONDI) AS INT) AS individus,
  CAST(AGED AS INT) AS AGED,
  DEPT AS departement
FROM table_individu
  WHERE DEPT IN ('11', '31', '34')
GROUP BY AGED, DEPT ORDER BY DEPT, AGED
`
)
Inputs.table(pyramide_ages)
```


```{ojs}
//| echo: false
//| fig-cap: Un exemple de représentation graphique produite à partir du recensement de la population

Plot.plot({
  x: {label: null},
  y: {percent: true},
  marks: [
    Plot.barY(
        pyramide_ages,
        {x: "AGED", y: d => d.individus/1000, fy: 'departement', fill: "departement", tip: true}
        ),
    Plot.ruleX([18], {stroke: "red"}),
    Plot.tickY(
        pyramide_ages,
        {x: "AGED", y: d => d.individus/1000, fy: 'departement'}
        ),
    Plot.ruleY([0]),
    Plot.axisY({label: "Population (en milliers)"}),
    Plot.axisX({ticks: d3.ticks(0, 120, 10), label: "Âge", fontSize: 12})
  ]
})
```


Si on s'intéresse plus spécifiquement au nombre de centenaires
recensés par département et qu'on désire classer ces derniers par 
ordre décroissant.

::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

{{< include snippets/12_centenaires_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/12_centenaires_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/12_centenaires_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/12_centenaires_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
Inputs.table(
  db.query(
  `
  SELECT
    CAST(SUM(IPONDI) AS INT) AS individus_recenses,
    DEPT
  FROM table_individu
    WHERE AGED >= 100
  GROUP BY DEPT
  ORDER BY individus_recenses DESC
  `
  )
)
```


# Associer à d'autres sources de données

Le [_code officiel géographique_ (COG)](https://www.insee.fr/fr/information/6800675)
est utile pour illuster l'ajout d'information annexe. 
Le code commune va être utilisé pour associer les deux bases
de données. Cette variable porte des noms différents dans les
deux bases, ce qui n'est pas un problème. 

Il est proposé, ci-dessous, de télécharger les données
de manière reproductible, via une fonction adaptée
(ici à travers le _package_ `requests` pour `Python` ou via `download.file` en `R`).
Bien que `DuckDB` permette l'import direct
depuis un _url_, ceci implique l'installation en amont
de l'[extension `httpfs`](https://duckdb.org/docs/extensions/httpfs.html). 

L'association de sources de données passe généralement par un `JOIN`. Pour illustrer
cette clause, il est possible d'associer les agrégats de la table logement
à un niveau communal avec celles du COG grâce au code commune. 


::: {.panel-tabset group="language"}

## `Observable` via `Quarto` {.unnumbered .unlisted}

La lecture directe depuis `Observable`
du fichier par le biais du protocole `https` vers
le site de l'Insee
ne fonctionnant pas,
il est recommandé de télécharger en amont le fichier
par l'intermédiaire de `Python` ou de `R`.

<details>
<summary>
Code <code>Python</code> pour récupérer le code officiel géographique
</summary>

```python
import requests
import os

url_cog = "https://www.insee.fr/fr/statistiques/fichier/6800675/v_commune_2023.csv"
if os.path.exists("cog.csv") is False:
  response = requests.get(url_cog)
  with open("cog.csv", mode="wb") as file:
      file.write(response.content)
```

</details>

<details>
<summary>
Code <code>R</code> pour récupérer le code officiel géographique
</summary>

```r
url <- "https://www.insee.fr/fr/statistiques/fichier/6800675/v_commune_2023.csv"
download.file(url, "cog.csv")
```

</details>


Après avoir récupérées les données, ce code peut permettre de créer
une base de données intégrant le code officiel géographique:

{{< include snippets/13_autres_sources_ojs.qmd >}}

## `Python` {.unnumbered .unlisted}

{{< include snippets/13_autres_sources_python.qmd >}}

## `R` {.unnumbered .unlisted} 

{{< include snippets/13_autres_sources_r.qmd >}}

## `R (dbplyr)` {.unnumbered .unlisted} 

{{< include snippets/13_autres_sources_r_dbplyr.qmd >}}

:::

```{ojs}
//| echo: false
proxy = "https://corsproxy.io/?"
url_cog = "https://www.insee.fr/fr/statistiques/fichier/6800675/v_commune_2023.csv"
db2 = {
  const configuredClient = await db ;
  await configuredClient.query(
    `
    CREATE OR REPLACE VIEW cog2023 AS
    SELECT * FROM read_csv_auto('${proxy + url_cog}', header = true)
    `
    )

  return configuredClient ;

}
```

Les données du code officiel géographique présentent l'aspect suivant :

```{ojs}
//| code-fold: true
//| code-summary: "Requête Observable pour explorer les premières lignes"
Inputs.table(
  db2.query(`SELECT * FROM cog2023 LIMIT 10`)
)
```

Voici par exemple le résultat d'une fusion
avec une agrégation produite à la volée sur la table logement :


```{ojs}
//| code-fold: true
//| code-summary: "Requête pour explorer les premières lignes"
Inputs.table(
  db2.query(
    `
    SELECT cog2023.NCCENR, CAST(SUM(table_logement.IPONDL) AS INT) AS recenses
    FROM table_logement
    LEFT OUTER JOIN cog2023 ON table_logement.COMMUNE = cog2023.COM
    GROUP BY cog2023.NCCENR
    ORDER BY recenses;
    `
  )  
)
```

## Références