Skip to content

Details

A practical two-hour session investigating how SQLx can detect invalid SQL, incompatible parameters, missing columns, and incorrect Rust mappings during compilation rather than after deployment.
The session follows a query through the boundary between Rust and the database: from the SQL text and bound parameters, through schema inspection and type analysis, to the Rust value returned to the application. We will deliberately break queries, change schemas, and introduce type mismatches to understand what SQLx can prove before runtime—and what it cannot.
The emphasis is not on memorizing an API. It is on understanding the engineering model behind compile-time checked SQL, the role of migrations in preserving that model, and the practical consequences for local development, testing, continuous integration, and deployment.
Audience: developers who want to understand how Rust can provide stronger guarantees around ordinary SQL without replacing SQL with an ORM or query language.
Outcomes:

  • Trace how SQLx validates a query during compilation
  • Understand how database metadata informs Rust type checking
  • See compile-time failures caused by invalid queries and incompatible result types
  • Understand why the current schema matters during a build
  • Connect database migrations to query correctness
  • Distinguish checked macros from runtime query APIs
  • Evaluate when compile-time SQL checking improves a project and when it adds friction

Format: two hours with a guided investigation, broken-query experiments, migration examples, discussion of operational tradeoffs, and a reusable checklist for database code.

------

Une session pratique de deux heures explorant comment SQLx peut détecter les requêtes SQL invalides, les paramètres incompatibles, les colonnes manquantes et les mappages Rust incorrects lors de la compilation plutôt qu'après le déploiement.
La session suit une requête à travers la frontière entre Rust et la base de données : du texte SQL et des paramètres liés, en passant par l'inspection du schéma et l'analyse de type, jusqu'à la valeur Rust renvoyée à l'application. Nous casserons délibérément des requêtes, modifierons des schémas et introduirons des incompatibilités de type pour comprendre ce que SQLx peut prouver avant l'exécution — et ce qu'il ne peut pas.
L'accent n'est pas mis sur la mémorisation d'une API. Il s'agit de comprendre le modèle d'ingénierie derrière le SQL vérifié à la compilation, le rôle des migrations dans la préservation de ce modèle, et les conséquences pratiques pour le développement local, les tests, l'intégration continue et le déploiement.
Public cible : développeurs souhaitant comprendre comment Rust peut offrir des garanties plus solides autour du SQL ordinaire sans remplacer le SQL par un ORM ou un langage de requête.
Résultats :

  • Suivre comment SQLx valide une requête lors de la compilation
  • Comprendre comment les métadonnées de la base de données informent la vérification de type de Rust
  • Voir les échecs à la compilation causés par des requêtes invalides et des types de résultats incompatibles
  • Comprendre pourquoi le schéma actuel est important lors d'une construction
  • Connecter les migrations de base de données à la correction des requêtes
  • Distinguer les macros vérifiées des API de requête à l'exécution
  • Évaluer quand la vérification SQL à la compilation améliore un projet et quand elle ajoute des frictions

Format : deux heures avec une investigation guidée, des expériences de requêtes cassées, des exemples de migration, une discussion sur les compromis opérationnels et une liste de contrôle réutilisable pour le code de base de données.

Related topics

Artificial Intelligence Applications
Professional Networking
Rust
Software Development
Rustlang

You may also like