From legacy queries to Dataform models

Between mid-2024 and early-2025 at GOZEM, my team and I migrated all our legacy scheduled queries into Dataform models. The improvements were immediate:

• Better dependency management, especially in models execution hierarchy.

• More maintainable modeling patterns.

• A stronger and more scalable foundation for our data transformations, with dependency integrity, CI/CD integration, and modular modeling that grows with our data volume.

It was a major step forward, but also the beginning of new challenges.

The limits of the basic implementation

Even though Dataform was a huge relief for our SQL pipelines, some pain points soon became apparent:

• Full-table assertions on large datasets. Most of the time we only needed to validate recently updated or created partitions, but the built-in model assertions scan the entire table; an unnecessary cost hit.

• Partition-aware merges. BigQuery MERGE statements only support explicit partition filters in the ON clause. Dataform doesn’t automatically detect or fetch partitions from source data. While updatePartitionFilter reduced unnecessary scans, it couldn’t dynamically handle composed filters or subqueries due to BigQuery’s constraints.

• Schema evolution headaches. Before version 3.0.3 introduced the onSchemaChange property in early 2025, every new column in a source table had to be manually added to the target. That meant extra dev time and more room for human error.

The trade-offs before the light

At that point, we survived through workarounds; long pre_operations blocks in some models, and even external Python scripts orchestrated in Airflow to prepare partition variables and handle schema quirks. They worked, but came at a cost: more development time, more complexity, and higher maintenance.

Our goal was simple: solve all of this directly in Dataform, and make it automatic.

In the sections below, I’ll explain how we extended basic Dataform into an advanced framework that could:

• Reduce repetitive model code.

• Cut assertion costs by scanning only updated partitions.

• Handle schema changes intelligently and safely.

• Remove external orchestration dependencies.

All while staying 100% native to BigQuery.

Abonnez-vous maintenant

The power of Dataform templating

We realized what we needed was full control over incremental model execution flow. Dataform’s operations models offered flexibility, but rewriting the same logic in every model wasn’t practical. So we built our own custom template, leveraging Dataform’s includes mechanism for repository-wide code reuse (functions, constants, and shared helpers).

That meant coding in JavaScript — a programming language I wasn’t fully comfortable with at first — and even rewriting parts of Dataform’s built-in logic to fit our workflow.

Our smart incremental custom flow

Our template follows this flow:

Check if the target table exists.

1. If not, create it like a non-incremental full refresh from the model query output and stop.

2. If yes, create a staging table from the model query output.

2.1. Compare the staging columns to the target.

2.1.1. If new columns are found, alter the target to add them.

2.2. Extract distinct partition values from the staging table.

2.3. Build a merge query with the ON clause scanning only those partitions: ON staging.key = target.key AND target.partition_column IN (partition_values).

3. Execute the merge.

4. Create assertion views filtered on those same partition values.

5. Assert the views instead of the entire table.

That’s it. Simple. Dynamic. Efficient.

The built-in updatePartitionFilter (eg: partitionColumn >= xPeriod) helped reduce merge costs, but it wasn’t flexible enough for our data changes. Our template dynamically identifies all updated partitions from the staging table and limits the merge to those areas only. This gives us fully refreshed data without manual runs, without external scripts, and without wasteful costs.

In addition to asserting only recently updated partitions, we have reduced more BigQuery costs and improved development speed — achieving smarter, faster, and fully native transformations.

Some additional nice-to-have features

Smarter ON clauses

Instead of relying on a dedicated transformed partition column, we directly integrate expressions like FUNCTION(target.partitionColumn) IN (partition_values) for greater simplicity and no additional column than needed, avoiding the target.FUNCTION error with updatePartitionFilter.

Advanced tables replacement

When partition or clustering columns change, BigQuery normally requires manual drops and recreations. Our framework automatically handles these updates.

Extended assertions

We went beyond the built-in data quality rules (uniqueKey, nonNull) to include checks like accepted_values, relationship, freshness, row_count, and percentage. Initially defined manually via rowConditions, they are now templated for faster and cleaner development.

Limited columns in assertions reports

Instead of using a wildcard in the assertions views, which shows all table columns when run, we add a property to specify only the columns we want to display in the assertions (views), reducing cost by leveraging BigQuery’s column-oriented capabilities.

We have significantly improved our SQL workflows using Dataform. With the right templates, it has everything needed to serve as a true all-in-one modeling engine within the BigQuery ecosystem. Our custom template showcased just how powerful Dataform’s operations models can be, and how much potential lies beyond the basics.

If you’re already using Dataform for advanced use cases, I’d love to learn from your experience.

You can explore the full template on GitHub: github.com/bolablg/gcp-dataform-modeling-lab. Although it is tailored to some specific needs now, I believe it can be extended to achieve more.

Mais dès qu’il s’agit d’importer des données depuis une source externe sans connecteur natif (comme une base de données produit), la tâche manuelle peut vite devenir répétitive et chronophage. Dans cette note, je montre comment automatiser, avec Python, la création, le remplissage, le formatage, le partage, et l’archivage d’un fichier Google Sheets. Une solution gratuite, efficace, et facile à mettre en place, pour se concentrer sur ce qui compte vraiment.

Abonnez-vous maintenant

Mise en situation

Répondre à un besoin métier… sans coder une usine à gaz

Tu accompagnes une PME qui vient de lancer une campagne ponctuelle d’acquisition et d’activation de clients via des agents commerciaux sur le terrain.

Principes d’enregistrement des données opérationnelles:

• Chaque nouveau compte créé chez un agent commercial est accompagné de l’identifiant unique de l’agent.

• Tout premier dépôt d’argent sur le compte client effectué chez un agent commercial est accompagné de l’identifiant unique de l’agent.

La PME veut rémunérer les agents selon leurs performances. Le problème ? Aucun outil interne ne permet pour le moment de calculer et payer tout ça convenablement, et les développeurs sont occupés sur une autre mission.

Tu es chargé de mettre en place un système simple: récupérer les données d’activité de la base de données MongoDB, croiser avec les seuils de configuration, calculer les rémunérations, et générer deux rapports; un pour la compta (salaire par agent), un pour le service support (récapitulatif de performance par agent). Le tout doit être fourni au quotidien, et envoyé aux bonnes équipes.

Règles de rémunération:

• Tout nouveau compte créé donne droit à 2.99 ECO

• Toute nouvelle recharge de compte donne droit à 1.99 ECO

• Un nouveau compte suivi d’une première recharge dans la même journée donne droit à u bonus de 0.99 ECO

Approche de solution

L’idée est simple: automatiser chaque étape du reporting, de l’extraction des données jusqu’à l’envoi des rapports aux équipes.

• Extraire les données de la période cible directement depuis la base.

• Nettoyer, filtrer et structurer les données sous forme de tableaux prêts à l’emploi.

• Créer automatiquement les fichiers Google Sheets dans les bons dossiers via l’API Google Drive.

• Remplir et formater les fichiers avec les bonnes données via l’API Google Sheets.

• Notifier les équipes concernées par email, une fois les rapports prêts.

• Automatiser l’ensemble dans un seul programme Python, exécuté de manière planifiée (quotidienne, etc.).

Implémentation de la solution

Quelques bonnes pratiques…

1. Se mettre d’accord avec les équipes sur:

   1. Quand livrer les rapports (par exemple, chaque jour à midi)

   2. Quels éléments doivent y figurer (colonnes, kpis, formats, filtres…)

2. Stocker chaque type de rapport (paiement, performance) dans un dossier Google Drive dédié, servant d’espace de partage, pour simplifier le contrôle des accès.

3. Adopter une convention de naming claire pour facilitera l’exploitation. (ex: {NomDeCampagne}-{TypeDeRapport}-{DateDesDonnées}). Cela suffirait à éviter toute confusion… mais pour renforcer la fiabilité, on pourra par exemple déplacer automatiquement l’ancien rapport de paiement vers un dossier d’archives, afin d’éviter les traitements double, tout en gardant un historique.

4. Créer une base des règles de rémunération afin de faciliter leurs mises à jour indépendamment du code (optionnel).

5. Créer une base de sauvegarde des métadonnées des rapports générées. (optionnel).

6. Faire valider manuellement le bon fonctionnement du programme (chiffres, formats, fichiers), idéalement avec un second regard, avant l’automatisation.

Étape 1 : Préparation de l’environnement et configuration des APIs Google

Pour automatiser des actions sur Google Drive et Google Sheets, votre programme doit utiliser un service account de google auquel vous attribuerez les permissions nécessaires. Si vous ne savez pas comment procéder, ce tutoriel vous guidera étape par étape.

import gspread
from google.oauth2 import service_account
from googleapiclient.discovery import build

scopes = [
    'https://www.googleapis.com/auth/spreadsheets',
    'https://www.googleapis.com/auth/drive'
]

sa_credentials = service_account.Credentials.from_service_account_file(chemin/vers/ta_cle.json')

creds = sa_credentials.with_scopes(scopes)
gw_client = gspread.authorize(credentials = creds)

Étape 2 : Création des fonctions personnalisées

Fonction: Générer automatiquement un google sheets

def create_sheet_get_id(sheet_title, folder_id, service_account_creds):
    '''
    This function will create a new google sheet file within a specific doogle drive folder.
    Args:
        sheet_title (str): The title of the new Google Sheet.( E.g. Tuto - Python x Google Sheets)
        folder_id (str): The ID of the Google Drive folder where the sheet will be created. If the link of the drive folder is https://drive.google.com/drive/folders/1a2b3c4d5e6f7g8h9i0j, then the folder_id is 1a2b3c4d5e6f7g8h9i0j.
        service_account_creds (service_account.Credentials): The service account credentials to authenticate with Google Drive API.
    '''
    drive_api = build('drive', 'v3', credentials=service_account_creds)

    # Create the new Google Sheet
    file_metadata = {'name': sheet_title, 'parents': [folder_id], 'mimeType': 'application/vnd.google-apps.spreadsheet',}
    newsheet = drive_api.files().create(body=file_metadata).execute()
    sheet_id = newsheet['id']
    
    return sheet_id

Fonction: Exporter des DataFrames vers google sheets

def fill_sheet_with_pandas_dataframes(sheet_id, data_frames_dict, service_account_creds):
    '''
    This function will fill a Google Sheet with data.
    Args:
        sheet_id (str): The ID of the Google Sheet to fill with data.
        data_frames_dict (dict): The data to fill the Google Sheet with. It should be a dictionary where keys are sheet names and values are pandas DataFrames.
        service_account_creds (service_account.Credentials): The service account credentials to authenticate with Google Sheets API.
    '''
    # Authorize the Google Sheets API
    gw_client = gspread.authorize(credentials=service_account_creds)
    workbook = gw_client.open_by_key(sheet_id)
    for sheet_name, df in data_frames_dict.items():
        if not isinstance(df, pd.DataFrame):
            raise TypeError(f"Data for sheet '{sheet_name}' must be a pandas DataFrame.")
        
        # Clear the existing content of the sheet
        try:
            worksheet = workbook.worksheet(sheet_name)
            worksheet.clear()
        except gspread.WorksheetNotFound:
            worksheet = workbook.add_worksheet(title=sheet_name, rows="100", cols="20")
        
        # Set the DataFrame to the Google Sheet
        set_with_dataframe(worksheet, df, include_index=False, include_column_header=True)
        print(f"Data for sheet '{sheet_name}' has been written to the Google Sheet.")
    
    sheet_to_delete = workbook.worksheet("Sheet1") # Delete the default sheet created by Google Sheets
    workbook.del_worksheet(sheet_to_delete)  

Fonction: Partager un google sheets avec un message

def share_google_sheet_with_message(sheet_id, email_list, acess, service_account_creds, message=""):
    # Authenticate with service account
    drive_service = build('drive', 'v3', credentials=service_account_creds)

    for email_to_share in email_list:
        # Create permission
        permission = {
            'type': 'user',
            'role': acess, #'reader',
            'emailAddress': email_to_share
        }

        # Share the file
        drive_service.permissions().create(
            fileId=sheet_id,
            body=permission,
            sendNotificationEmail=True,
            emailMessage=message
        ).execute()

    print(f"Google Sheet shared with {email_to_share} as {acess}.")

Étape 3 : Initialisation des variables globales

Dans cette étape, on définit des variables clés qu’on réutilisera tout au long du script. Cela permet d’éviter les répétitions et de rendre le code plus clair et plus facile à maintenir. Dans notre cas, on définit simplement les bornes de l’intervalle de la période à traiter. Ces dates serviront aussi à nommer automatiquement les fichiers générés plus tard.

Etape 4: Extraction et traitement des données

Ici, tu récupères les données issues de la base d’activité, puis tu les analyses pour calculer les indicateurs à fournir à chaque équipe. Dans notre application, nous exploitons les données d’une base-test mongodb:

• la table des agents commerciaux

• la table des comptes clients

• la table des transactions

Étape 5 : Export des rapports d’analyse et notification des équipes

Une fois les traitements de données terminés, tu utilises les fonctions définies plus haut pour les exporter vers les dossiers drive des équipes concernées. La notification, bien qu’optionnelle, permet d’envoyer automatiquement un email à l’adresse de ton choix pour l’informer que les rapports sont disponibles.

Deux options sont envisageables :

• Partager le fichier avec un message personnalisé (via Drive API)

• Envoyer un véritable email contenant les infos utiles (via Gmail API)

Dans cet exemple, j’ai opté pour la première solution, simple et rapide à mettre en place.

NB: Le notebook final de ce tutoriel est accessible dans ce dépôt GitHub. Pour automatiser l’exécution de votre programme, convertissez votre notebook en script .py et planifier son execution sur un serveur via cron ou un orchestrateur comme Airflow.

⚠️ DISCLAIMER ⚠️

• Some parts of this article have been reformulated with ChatGPT.

• The header image has been generated with ChatGPT.

Partager

Tu veux automatiser des fichiers Google Sheets ou organiser des sauvegardes sur Google Drive avec Python ou un autre langage ? Alors tu vas avoir besoin d’un Service Account. Mais si tu ne sais même pas ce que c’est, pas de panique: cet article t’explique tout depuis zéro.

Abonnez-vous maintenant

C’est quoi un Service Account ?

Un Service Account est un compte spécial créé pour une application ou un script, pas pour un humain. Il peut accéder à des services Google (comme Google Sheets ou Drive) de manière automatique et sécurisée, avec les droits que tu lui donnes.

Tu peux l’imaginer comme un robot à qui tu donnes une carte d’identité et une clé pour bosser à ta place dans l’environnement Google.

Prérequis

• Une adresse Gmail

• 10 minutes de ton temps

Étape 1 : Créer un projet Google Cloud

1. Va sur https://console.cloud.google.com (accepte les conditions d’utilisation en cas de première visite avant de continuer.)

2. Clique sur le menu de sélection de projet1 en haut à gauche.

3. Clique sur “Nouveau projet”.

4. Donne-lui un nom (ex : automation-project) et clique sur “Créer”.

Une fois créé, sélectionne ton projet dans la liste.

Étape 2 : Créer un Service Account

1. Dans le menu de gauche, clique sur “IAM et administration” > “Comptes de service”.

2. Clique sur “Créer un compte de service”2.

3. Donne-lui un nom (ex : script-automator) et clique sur “Créer et continuer”.

4. Laisse les options de rôle vides ou choisis “Éditeur” si nécessaire, puis clique sur “Terminer”.

Étape 3 : Générer la clé du Service Account (fichier JSON)

1. Dans la liste des comptes de service, clique sur les 3 points à droite de celui que tu viens de créer.

2. Choisis “Gérer les clés”.

3. Clique sur “Ajouter une clé” > “Créer une clé”.

4. Sélectionne JSON et clique sur “Créer” ou “OK”.

5. Un fichier .json va être téléchargé : garde-le bien ! Tu l’utiliseras dans ton script.

⚠️ Ne partage jamais ce fichier, il donne un accès complet à ton compte.

Étape 4 : Activer les API Google Sheets & Drive

1. Dans le menu de gauche, clique sur “API et services3” > “Bibliothèque”.

2. Recherche “Google Sheets API”, clique dessus, puis clique sur “Activer”.

3. Refais la même chose avec “Google Drive API”.

Étape 5 : Donner accès à un dossier Drive au Service Account

1. Ouvre ton fichier JSON, cherche la ligne "client_email" : elle contient une adresse email comme mon-compte@mon-projet.iam.gserviceaccount.com.

2. Va sur Google Drive, crée un dossier (ou utilise un existant).

3. Clique droit dessus > “Partager”.

4. Ajoute l’email du Service Account avec le rôle “Éditeur”.

Maintenant, ton robot (Service Account) peut lire, écrire et modifier dans ce dossier.

Étape 6 : Exemple d’utilisation en Python

Voici comment utiliser ton Service Account pour accéder à un fichier Google Sheet4 :

import gspread
from google.oauth2 import service_account

scopes = [
    'https://www.googleapis.com/auth/spreadsheets',
    'https://www.googleapis.com/auth/drive'
]

sa_credentials = service_account.Credentials.from_service_account_file(chemin/vers/ta_cle.json')

creds = sa_credentials.with_scopes(scopes)
gw_client = gspread.authorize(credentials = creds)

workbook = gw_client.open("Tuto - Python x Google Sheets")
sheet1 = workbook.sheet1
print(sheet.get_all_records())

NB: Si ton dossier Drive contient plusieurs fichiers ayant le même nom, il est préférable d'ouvrir le fichier voulu avec gspread5 en utilisant directement son lien ou son ID.

sheet_by_link = gw_client.open_by_url("https://docs.google.com/spreadsheets/d/15vnGxZzLHR1LwulS-bfIg82wOwanjWm-jr9OC40BiM0").sheet1

sheet_by_key = gw_client.open_by_key("15vnGxZzLHR1LwulS-bfIg82wOwanjWm-jr9OC40BiM0").worksheet("new_sheet")

⚠️ DISCLAIMER ⚠️

• Some parts of this article have been generated with ChatGPT.

• The header image has been generated with Gemini.

Partager

• l’Etat (gouvernement, administrations publiques…)

• les institutions privées indépendantes,

• les organisations régionales ou internationales.

Abonnez-vous maintenant

Les répertoires de données de l’Etat béninois

L’INStaD* (ex INSAE*) est l’organisme national de référence en terme de donnée officielle en République du Bénin. Son Directeur Général, qui est aussi le Secrétaire du CNS*, a l’autorité de valider les enquêtes et recensements dans le pays, délivrant un Visa statistique, garant de leur officialité sur le territoire national. L'INStaD diffuse régulièrement des données nationales et validées sur ses sites web. Sur son site principal, elle offre un accès à une multitude de statistiques et d'indicateurs actualisés, des résultats d’enquêtes et des chiffres de recensements, diffusés suivant un calendrier préétabli chaque début d'année (exemple: le calendrier de 2021). L’INStaD partage aussi des informations validées sur les plateformes ci-après:

NADA

La National Data Archive est un portail web conçu faciliter l’accès à un vaste catalogue de données, en vue de permettre leur ré-exploitation pour de nouveaux traitements scientifiques. Elle est pratique pour explorer, rechercher, comparer et télécharger des données issues de recensements ou d'enquêtes diverses. Vous y trouverez des micro et de métadonnées soigneusement documentées, avec la possibilité de contacter l'INStaD pour obtenir des détails supplémentaires.

Benin Data Portal

Il s’agit du portail officiel des données ouvertes du Bénin. Il offre un accès direct aux informations classées et organisées provenant de diverses institutions nationales comme l'INStaD et le Ministère de l’Économie et des Finances. Benin Data Portal facilite l'accès et améliore la gestion des données pour tous les utilisateurs.

Il est possible de visualiser et de télécharger les données publiées sur ces plateformes. Cependant, le téléchargement des données sous licence nécessite une identification de l’usager (créer un compte, se connecter). Pour en savoir plus sur les mentions légales et crédit appliqués par l’INStaD, visiter cette page.

Etat des lieux de l’ouverture des données au Bénin

En 2020, dans son inventaire des données ouvertes, Open Data Watch a classé le Bénin 83ème sur 187 dans le monde. Avec un score global de 52/100, une combinaison de 44 pour la couverture et 60 pour l'ouverture, le Bénin a réussi à se hisser légèrement au dessus de la moyenne.

La couverture est notée sur la base de la disponibilité des indicateurs publiés, sur le nombre d'observations disponibles au cours des dix dernières années et sur l'existence de données nationales et territoriales.

Quant aux scores d'ouverture, ils sont basés sur le format et les licences des ensembles de données, l'exhaustivité des métadonnées et les options de téléchargement existantes.

Pour en savoir plus sur la maturité du Bénin en terme d’ouverture de données, vous pouvez consulter le portail ODIN (Open Data Inventory) de Open Data Watch.

Les sources des organisations privées: Cas des données d’enquête d’Afrobaromètre

Plusieurs institutions privées de recherche produisent des données sur différents pays. Parmi celles-ci, Afrobaromètre se distingue en menant des enquêtes de terrain et en publiant régulièrement ses analyses. En plus de diffuser les résultats sous plusieurs formes, Afrobaromètre offre également un accès public aux données brutes de ses enquêtes. Cette initiative est particulièrement utile pour les étudiants et chercheurs qui souhaitent explorer des variables spécifiques et adopter leurs propres perspectives d'analyse. Le Bénin est l'un des nombreux pays où Afrobaromètre opère.

Les données du Bénin sont accessibles sur le site internet d’Afrobaromètre où une page est également dédiée aux conditions d’usage desdites données.

Les banques de données internationales: cas des organisations régionales ou mondiales

Les organisations internationales telles que les Nations Unies, la Banque Mondiale, la GIZ, etc… sont connues pour financer des enquêtes pour recueillir des données dans différents pays. Elles produisent des données sur leurs pays membre ou les pays où elles ont des représentations. Ci-dessous, quelques exemples de banques de données internationales où vous trouverez des données sur le Bénin (ou autre pays), de la donnée parfois indisponible même sur les plateformes de statistiques nationales.

World Bank Data

Il s’agit d’un important catalogue de données ouvertes de la Banque mondiale, l’un des plus grands au monde. Pour télécharger les données complètes (brutes) liées aux indicateurs pays qu’on y trouve, les utilisateurs doivent créer un compte sur la plateforme des microdonnées de la banque mondiale et fournir un motif d'utilisation, souvent sous la forme d'une brève description de leur projet de recherche. Cette plateforme permet d'accéder gratuitement aux données de la Banque mondiale, ainsi que celles provenant d'autres organisations internationales, agences statistiques et divers acteurs. Elle inclut des données issues d'enquêtes réalisées pour des évaluations d'impact et des recherches en développement, ainsi que des données administratives.

DHS Data

Le gouvernement américain à travers l’USAID se consacre aux enjeux démographiques et de santé à travers le monde, en finançant des enquêtes pour mieux comprendre ces questions. Parmi celles-ci, les enquêtes démographiques et de santé (EDS), menées par l'INStaD au Bénin, fournissent des données précieuses. Pour y accéder, il est nécessaire de créer un compte et de présenter un projet de recherche.

ILOstat

L'Organisation internationale du travail fournit des données importantes sur des sujets comme l'emploi, les niveaux de revenu et le seuil de pauvreté dans son catalogue. Son RestAPI NADA permet de programmatiquement rechercher, de parcourir et de visualiser son catalogue de métadonnées.

UNdata

Le répertoire des données des Nations Unies donne accès à un large éventail de statistiques touchant à des sujets d’intérêt général. Généralement, aucune identification ni justification n’est requise pour explorer ou télécharger les données de ce catalogue.

La liste des sources de données mentionnées dans cet article est non exhaustive. Pour trouver des informations d’un domaine spécifique, il est recommandé de consulter les sites web d'organisations ou d'institutions spécialisées reconnues dans le domaine. Ainsi, par exemple, la World Health Organization Data Collections s’avère la mieux indiquée pour des données de santé, et l’on devrait commencer toute recherche de données sur les réfugiés par la UN Refugee Agency Microdata Library.

Internet offre un accès facile à une vaste gamme de données, toutes à portée de clic. Toutefois, il est crucial de lire attentivement les conditions d'utilisation avant de télécharger des données afin d'éviter toute utilisation non autorisée.

_

INStaD: Institut National de la Statistique et de la Démographie

INSAE: Institut National de la Statistique et de l’Analyse Economique

CNS: Conseil National de la Statistique

Partager