PricingLoginStart free
Elixir & Phoenix: Scalable Backend Development · Leçon

Transactions et Ecto.Multi

Regroupez plusieurs opérations de base de données en unités atomiques grâce aux transactions de Repo et à la structure Ecto.Multi composable.

Leçon 4 sur 413 étapes

Transactions et Ecto.Multi est une leçon Elixir & Phoenix: Scalable Backend Development gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Elixir & Phoenix: Scalable Backend Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Pourquoi utiliser des transactions ?

Une transaction regroupe plusieurs opérations afin qu’elles réussissent toutes ou soient toutes annulées ensemble, ce qui préserve la cohérence des données.

Repo.transaction avec une fonction

La forme la plus simple exécute une fonction : si celle-ci se termine normalement, la transaction est validée ; si elle lève une exception, elle est annulée.

Repo.transaction(fn ->
  Repo.insert!(%Account{balance: 100})
  Repo.insert!(%Log{action: "created"})
end)

Annulation manuelle

Dans la fonction, vous pouvez interrompre explicitement l’opération avec Repo.rollback/1, qui renvoie {:error, reason}.

Repo.transaction(fn ->
  case withdraw(account, 50) do
    {:ok, acc} -> acc
    {:error, r} -> Repo.rollback(r)
  end
end)

Le problème des fonctions imbriquées

Les transactions fondées sur des fonctions deviennent difficiles à lire et à réutiliser lorsque les étapes dépendent de résultats précédents. Ecto.Multi résout ce problème de manière déclarative.

Construire un Ecto.Multi

Ecto.Multi est une structure qui accumule des opérations nommées sans toucher à la base de données avant son exécution.

alias Ecto.Multi
multi =
  Multi.new()
  |> Multi.insert(:user, %User{name: "Ada"})

Enchaîner les opérations

Chaque opération reçoit un nom unique, ce qui vous permet de faire référence aux résultats précédents et de les inspecter ultérieurement.

Multi.new()
|> Multi.insert(:user, user_changeset)
|> Multi.insert(:profile, profile_changeset)

Dépendre des étapes précédentes

Transmettez une fonction pour utiliser les résultats des étapes précédentes. Elle reçoit le dépôt et une table associative des opérations terminées.

Multi.new()
|> Multi.insert(:user, user_changeset)
|> Multi.run(:welcome, fn _repo, %{user: user} ->
  send_welcome(user)
end)

Exécuter le Multi

Repo.transaction/1 exécute l’ensemble du Multi de manière atomique et renvoie {:ok, results} ou un tuple d’erreur.

case Repo.transaction(multi) do
  {:ok, %{user: user}} -> {:ok, user}
  {:error, step, reason, _} -> {:error, step, reason}
end

Identifier précisément les échecs

En cas d’échec, le tuple d’erreur indique exactement l’étape qui a échoué et fournit les modifications effectuées jusque-là (qui ont été annulées).

{:error, :profile, changeset, _changes_so_far}

Autres opérations de Multi

Multi prend en charge update, delete, update_all et delete_all, à l’image des fonctions de Repo.

Multi.new()
|> Multi.update(:acc, changeset)
|> Multi.delete_all(:logs, old_logs_query)

Les avantages de la composition

Comme un Multi n’est que des données, vous pouvez le construire par morceaux dans différentes fonctions et lui ajouter des étapes avant de l’exécuter, ce qui facilite les tests.

def base_multi, do: Multi.new() |> Multi.insert(:user, cs)
# elsewhere
base_multi() |> Multi.insert(:audit, audit_cs) |> Repo.transaction()

Vérification rapide

Testez vos connaissances sur les transactions.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez rendu les modifications de la base de données atomiques :

  • Repo.transaction avec une fonction valide ou annule l’ensemble
  • Repo.rollback interrompt explicitement l’opération
  • Ecto.Multi compose des étapes nommées sous forme de données
  • Les échecs renvoient le nom de l’étape concernée et annulent tout
Gratuit pour commencer

Apprends Elixir avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
12
Leçons
48
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Transactions et Ecto.Multi » est-elle gratuite ?

Oui — le texte complet de « Transactions et Ecto.Multi » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Elixir & Phoenix: Scalable Backend Development, passe à CoddyKit PRO. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Transactions et Ecto.Multi » ?

Regroupez plusieurs opérations de base de données en unités atomiques grâce aux transactions de Repo et à la structure Ecto.Multi composable. Tu pratiques Elixir & Phoenix: Scalable Backend Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Elixir & Phoenix: Scalable Backend Development ?

Aucune expérience préalable n'est requise. Elixir & Phoenix: Scalable Backend Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Transactions et Ecto.Multi » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Elixir & Phoenix: Scalable Backend Development ?

Oui. Chaque leçon Elixir & Phoenix: Scalable Backend Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Schémas Ecto et migrations de base de données
  2. Repo, Changesets et requêtes
  3. Associations et schémas intégrés
  4. Transactions et Ecto.Multi
← Retour à Elixir & Phoenix: Scalable Backend Development