Transaktioner och datamanipulation
Utför atomiska transaktioner på Mnesia-tabeller och säkerställ datakonsistens mellan distribuerade noder.
Transaktioner och datamanipulation är en gratis lektion i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Erlang OTP: Programmering av distribuerade och feltoleranta system, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Varför behöver Mnesia transaktioner?
Föreställ Er att Ni hanterar viktiga data, till exempel banköverföringar. Ni vill väl inte att pengar lämnar ett konto utan att komma fram till ett annat?
Denna princip om "allt eller inget" är avgörande för datakonsistensen, och det är här transaktioner kommer in. Mnesia använder transaktioner för att gruppera flera databasoperationer till en enda atomär enhet.
En atomär transaktion slutför antingen alla sina operationer, eller så återställs alla ändringar om någon del misslyckas. Det säkerställer att Era data förblir konsistenta och tillförlitliga.
Kärnan: `mnesia:transaction`
I Mnesia utför Ni transaktionella operationer med funktionen mnesia:transaction/1. Den tar en anonym funktion (en fun) som argument.
Alla Mnesia-läs- och skrivoperationer som måste vara atomära ska placeras i denna fun. Om fun körs utan fel verkställs ändringarna. Om ett fel inträffar eller mnesia:abort/1 anropas återställs alla ändringar.
Här är dess grundläggande struktur:
-module(example_transaction).
-export([main/0]).
main() ->
mnesia:start(),
{atomic, _Result} = mnesia:transaction(fun() ->
% Mnesia operations go here
io:format("Inside the transaction!~n"),
ok
end),
io:format("Transaction completed.~n"),
mnesia:stop().Förbered data för transaktioner
Innan vi kan manipulera data behöver vi en Mnesia-tabell. Låt oss definiera en enkel person-record och skapa en tabell för den. Denna konfiguration kommer att användas i våra transaktionsexempel.
Kom ihåg att mnesia:create_table/2 vanligtvis anropas en gång när applikationen startas första gången.
-module(mnesia_table_setup).
-export([main/0]).
-record(person, {id, name, age}).
main() ->
% Ensure Mnesia is started on this node
mnesia:create_schema([node()]),
mnesia:start(),
% Create table if it doesn't exist
case mnesia:create_table(person, [{attributes, record_info(fields, person)}]) of
{atomic, ok} -> io:format("Table 'person' created successfully.~n");
{aborted, {already_exists, person}} -> io:format("Table 'person' already exists.~n");
Error -> io:format("Error creating table: ~p~n", [Error])
end,
mnesia:stop().Lägg till och uppdatera records
Inuti en transaktion använder Ni mnesia:write/1 för att lagra eller uppdatera records. Om det redan finns en record med samma primärnyckel (det första fältet i vår person-record, id) uppdateras den. Annars infogas en ny record.
Låt oss lägga till en ny person i vår tabell. Kom ihåg att starta Mnesia först!
-module(write_example).
-export([main/0]).
-record(person, {id, name, age}).
main() ->
% Ensure Mnesia is started and table exists (simplified setup)
mnesia:create_schema([node()]),
mnesia:start(),
mnesia:create_table(person, [{attributes, record_info(fields, person)}]),
mnesia:wait_for_tables([person], 5000),
% Write a new person record
Person1 = #person{id = 1, name = "Alice", age = 30},
{atomic, ok} = mnesia:transaction(fun() ->
mnesia:write(Person1)
end),
io:format("Wrote: ~p~n", [Person1]),
mnesia:stop().Hämta records transaktionellt
För att hämta data i en transaktion använder Ni mnesia:read/1. Den tar en record eller en recordnyckel (som {person, 1}) och returnerar en lista med matchande records. Om ingen record hittas returneras [] (en tom lista).
Låt oss läsa personen vi nyss lade till. Vi kombinerar skrivning och läsning i en enda transaktion för ett mer komplett exempel.
-module(read_example).
-export([main/0]).
-record(person, {id, name, age}).
main() ->
mnesia:create_schema([node()]),
mnesia:start(),
mnesia:create_table(person, [{attributes, record_info(fields, person)}]),
mnesia:wait_for_tables([person], 5000),
Person1 = #person{id = 1, name = "Alice", age = 30},
Person2 = #person{id = 2, name = "Bob", age = 25},
{atomic, Result} = mnesia:transaction(fun() ->
% Write two records
mnesia:write(Person1),
mnesia:write(Person2),
% Read one of them
mnesia:read({person, 1})
end),
io:format("Transaction result (read data): ~p~n", [Result]),
mnesia:stop().Ändra data med transaktioner
mnesia:write/1 hanterar både infogning av nya records och uppdatering av befintliga. För att ta bort en record helt använder Ni mnesia:delete/1 och anger hela recorden eller bara dess nyckel.
Låt oss uppdatera Alices ålder och sedan ta bort Bob från vår Mnesia-tabell, allt inom en enda konsistent transaktion.
-module(update_delete_example).
-export([main/0]).
-record(person, {id, name, age}).
main() ->
mnesia:create_schema([node()]),
mnesia:start(),
mnesia:create_table(person, [{attributes, record_info(fields, person)}]),
mnesia:wait_for_tables([person], 5000),
% Ensure initial data for update/delete
mnesia:transaction(fun() ->
mnesia:write(#person{id = 1, name = "Alice", age = 30}),
mnesia:write(#person{id = 2, name = "Bob", age = 25})
end),
io:format("--- Before transaction ---~n"),
io:format("Alice: ~p~n", [mnesia:dirty_read({person, 1})]),
io:format("Bob: ~p~n", [mnesia:dirty_read({person, 2})]),
{atomic, _} = mnesia:transaction(fun() ->
% Update Alice's age
UpdatedAlice = #person{id = 1, name = "Alice", age = 31},
mnesia:write(UpdatedAlice),
% Delete Bob
mnesia:delete({person, 2})
end),
io:format("--- After transaction ---~n"),
io:format("Alice: ~p~n", [mnesia:dirty_read({person, 1})]),
io:format("Bob: ~p~n", [mnesia:dirty_read({person, 2})]), % Should be []
mnesia:stop().Transaktionsåterställning i praktiken
Transaktionernas styrka ligger i deras atomicitet. Om någon operation i fun misslyckas eller om Ni uttryckligen anropar mnesia:abort/1 återställer Mnesia alla ändringar som gjorts under transaktionen.
Det innebär att databasens tillstånd återgår till hur det var innan transaktionen startade, vilket förhindrar delvisa uppdateringar och bevarar konsistensen.
-module(rollback_example).
-export([main/0]).
-record(person, {id, name, age}).
main() ->
mnesia:create_schema([node()]),
mnesia:start(),
mnesia:create_table(person, [{attributes, record_info(fields, person)}]),
mnesia:wait_for_tables([person], 5000),
% Ensure Alice exists initially
mnesia:transaction(fun() ->
mnesia:write(#person{id = 1, name = "Alice", age = 30})
end),
io:format("Initial Alice: ~p~n", [mnesia:dirty_read({person, 1})]),
% Attempt a transaction that will abort
Result = mnesia:transaction(fun() ->
mnesia:write(#person{id = 1, name = "Alice", age = 35}), % Update
mnesia:write(#person{id = 3, name = "Charlie", age = 22}), % New record
mnesia:abort("Something went wrong!") % Abort the transaction
end),
io:format("Transaction result: ~p~n", [Result]),
io:format("Alice after aborted transaction: ~p~n", [mnesia:dirty_read({person, 1})]),
io:format("Charlie after aborted transaction: ~p~n", [mnesia:dirty_read({person, 3})]),
mnesia:stop().`mnesia:sync_transaction/1` för global verkställning
Medan mnesia:transaction/1 säkerställer lokal atomicitet garanterar dess returvärde inte att transaktionen har verkställts på alla Mnesia-repliker i en distribuerad miljö. För det använder Ni mnesia:sync_transaction/1.
mnesia:sync_transaction/1 blockerar anroparen tills transaktionen har verkställts på alla noder där de berörda tabellerna finns. Detta är avgörande för starka konsistensgarantier i distribuerade system.
Använd den när Ni absolut behöver veta att data är konsistenta i hela klustret innan Ni går vidare.
-module(sync_transaction_example).
-export([main/0]).
-record(item, {id, name}).
main() ->
% This example assumes a distributed Mnesia setup.
% For a single node, it behaves like mnesia:transaction/1.
mnesia:create_schema([node()]),
mnesia:start(),
mnesia:create_table(item, [{attributes, record_info(fields, item)}]),
mnesia:wait_for_tables([item], 5000),
Item = #item{id = 101, name = "Widget A"},
io:format("Attempting sync_transaction...~n"),
{atomic, ok} = mnesia:sync_transaction(fun() ->
mnesia:write(Item)
end),
io:format("Item written and committed across all replicas: ~p~n", [Item]),
mnesia:stop().Kontroll av transaktionskunskaper
Ni har lärt Er om Mnesia-transaktioner och hur man manipulerar data atomärt. Låt oss testa Er förståelse!
Transaktioner: skyddsnätet för Era data
I den här lektionen har Ni lärt Er Mnesia-transaktioner, en grundpelare för att bygga robusta och tillförlitliga applikationer.
- Vi lärde oss att transaktioner ger atomicitet och säkerställer dataoperationer enligt principen "allt eller inget".
- Ni övade på att använda
mnesia:transaction/1för att gruppera Mnesia-operationer. - Vi gick igenom
mnesia:write/1för att lägga till och uppdatera,mnesia:read/1för att hämta ochmnesia:delete/1för att ta bort records. - Vi berörde kort
mnesia:sync_transaction/1för stark distribuerad konsistens.
Härnäst går vi igenom hur Mnesia konfigureras för distribuerad drift, inklusive datareplikering och feltålig lagring över ett kluster.
Lär dig Erlang 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
Vanliga frågor
Är lektionen ”Transaktioner och datamanipulation” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Erlang OTP: Programmering av distribuerade och feltoleranta system, inklusive ”Transaktioner och datamanipulation”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Vad lär jag mig i ”Transaktioner och datamanipulation”?
Utför atomiska transaktioner på Mnesia-tabeller och säkerställ datakonsistens mellan distribuerade noder. Ni övar på Erlang OTP: Programmering av distribuerade och feltoleranta system 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 Erlang OTP: Programmering av distribuerade och feltoleranta system?
Du behöver inga förkunskaper. Utbildningen i Erlang OTP: Programmering av distribuerade och feltoleranta system 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 2 av 4.
Hur lång tid tar lektionen ”Transaktioner och datamanipulation”?
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 Erlang OTP: Programmering av distribuerade och feltoleranta system-lektionen?
Ja. Varje Erlang OTP: Programmering av distribuerade och feltoleranta system-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
- Grunderna i Mnesia och scheman
- Transaktioner och datamanipulation
- Distribuerad Mnesia och replikering
- Mnesia-indexering och frågeoptimering