Elixir och Phoenix: skalbar backendutveckling · Lektion

Transaktioner och Ecto.Multi

Gruppera flera databasoperationer i atomära enheter med Repo-transaktioner och den komponerbara strukturen Ecto.Multi.

Lektion 4 av 413 steg

Transaktioner och Ecto.Multi är en gratis lektion i Elixir och Phoenix: skalbar backendutveckling på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Elixir och Phoenix: skalbar backendutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Elixir och Phoenix: skalbar backendutveckling innehåller totalt 4 lektioner.

Varför transaktioner?

En transaction samlar flera operationer så att de antingen lyckas allihop eller återställs tillsammans, vilket håller data konsekvent.

Repo.transaction med en funktion

Den enklaste formen kör en funktion. Om den returnerar normalt verkställs transaktionen, och om den kastar ett fel återställs den.

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

Manuell återställning

Inuti funktionen kan Ni avbryta uttryckligen med Repo.rollback/1, som returnerar {:error, reason}.

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

Problemet med nästlade funktioner

Funktionsbaserade transaktioner blir svåra att läsa och återanvända när stegen beror på tidigare resultat. Ecto.Multi löser detta deklarativt.

Bygga en Ecto.Multi

Ecto.Multi är en struct som samlar namngivna operationer utan att kontakta databasen förrän den körs.

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

Kedja operationer

Varje operation får ett unikt namn, så att Ni kan hänvisa till tidigare resultat och granska dem senare.

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

Bero på tidigare steg

Skicka in en funktion för att använda resultaten från tidigare steg. Den får repot och en map med slutförda operationer.

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

Köra Multi

Repo.transaction/1 kör hela Multi atomiskt och returnerar {:ok, results} eller en feltuple.

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

Lokalisera fel

Vid fel anger feltuplen exakt vilket steg som misslyckades och visar ändringarna som gjorts dittills (och som återställdes).

{:error, :profile, changeset, _changes_so_far}

Andra Multi-operationer

Multi stöder update, delete, update_all och delete_all, som motsvarar funktionerna i Repo.

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

Fördelarna med komponerbarhet

Eftersom en Multi bara är data kan Ni bygga den i delar i olika funktioner och lägga till fler steg innan den körs, vilket gör den enklare att testa.

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

Snabbkontroll

Testa Era kunskaper om transaktioner.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni gjorde databasändringar atomiska:

Repo.transaction med en funktion verkställer eller återställer allt tillsammans
Repo.rollback avbryter uttryckligen
Ecto.Multi komponerar namngivna steg som data
Fel returnerar namnet på det misslyckade steget och återställer allt

Gratis att börja

Lär dig Elixir med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Transaktioner och Ecto.Multi” gratis?

Ja – hela texten till ”Transaktioner och Ecto.Multi” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Elixir och Phoenix: skalbar backendutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Elixir och Phoenix: skalbar backendutveckling innehåller totalt 4 lektioner.

Vad lär jag mig i ”Transaktioner och Ecto.Multi”?

Gruppera flera databasoperationer i atomära enheter med Repo-transaktioner och den komponerbara strukturen Ecto.Multi. Ni övar på Elixir och Phoenix: skalbar backendutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Elixir och Phoenix: skalbar backendutveckling?

Du behöver inga förkunskaper. Utbildningen i Elixir och Phoenix: skalbar backendutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Transaktioner och Ecto.Multi”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Elixir och Phoenix: skalbar backendutveckling-lektionen?

Ja. Varje Elixir och Phoenix: skalbar backendutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Elixir och Phoenix: skalbar backendutveckling