Elixir en Phoenix: schaalbare backendontwikkeling · Les

Transacties en Ecto.Multi

Groepeer meerdere databasebewerkingen in atomaire eenheden met Repo-transacties en de samenstelbare Ecto.Multi-structuur.

Les 4 van 413 stappen

Transacties en Ecto.Multi is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Waarom transacties?

Een transactie bundelt meerdere bewerkingen, zodat ze allemaal slagen of allemaal samen worden teruggedraaid en de gegevens consistent blijven.

Repo.transaction met een functie

De eenvoudigste vorm voert een functie uit; als die normaal terugkeert, wordt de transactie vastgelegd, en als de functie een fout veroorzaakt, wordt alles teruggedraaid.

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

Handmatig terugdraaien

In de functie kun je expliciet afbreken met Repo.rollback/1, dat {:error, reason} teruggeeft.

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

Het probleem met geneste functies

Transacties op basis van functies worden moeilijk te lezen en opnieuw te gebruiken wanneer stappen afhankelijk zijn van eerdere resultaten. Ecto.Multi lost dit declaratief op.

Een Ecto.Multi opbouwen

Ecto.Multi is een structuur die benoemde bewerkingen verzamelt zonder de database aan te raken totdat je de bewerkingen uitvoert.

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

Bewerkingen aan elkaar koppelen

Elke bewerking krijgt een unieke naam, zodat je naar eerdere resultaten kunt verwijzen en ze later kunt inspecteren.

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

Afhankelijk zijn van eerdere stappen

Geef een functie door om de resultaten van eerdere stappen te gebruiken. Deze ontvangt de repo en een kaart met voltooide bewerkingen.

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

De Multi uitvoeren

Repo.transaction/1 voert de volledige Multi atomair uit en geeft {:ok, results} of een fouttuple terug.

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

Fouten precies lokaliseren

Bij een fout benoemt de fouttuple precies welke stap is mislukt en welke wijzigingen tot dan toe zijn aangebracht (en zijn teruggedraaid).

{:error, :profile, changeset, _changes_so_far}

Andere Multi-bewerkingen

Multi ondersteunt update, delete, update_all en delete_all, overeenkomstig met Repo-functies.

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

Voordelen van samenstelbaarheid

Omdat een Multi gewoon gegevens is, kun je die in delen over meerdere functies opbouwen en vóór uitvoering meer stappen toevoegen. Dat maakt testen eenvoudiger.

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

Korte controle

Test je kennis van transacties.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt databasewijzigingen atomair gemaakt:

Repo.transaction met een functie legt alles samen vast of draait alles samen terug
Repo.rollback breekt expliciet af
Ecto.Multi stelt benoemde stappen samen als gegevens
Fouten geven de naam van de mislukte stap terug en draaien alles terug

Gratis beginnen

Leer Elixir met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Transacties en Ecto.Multi” gratis?

Ja — de volledige tekst van “Transacties en Ecto.Multi” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.

Wat leer ik in “Transacties en Ecto.Multi”?

Groepeer meerdere databasebewerkingen in atomaire eenheden met Repo-transacties en de samenstelbare Ecto.Multi-structuur. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?

Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Transacties en Ecto.Multi”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Elixir en Phoenix: schaalbare backendontwikkeling?

Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Elixir en Phoenix: schaalbare backendontwikkeling