Elixir और Phoenix: स्केलेबल बैकएंड विकास · पाठ

लेन-देन और Ecto.Multi

Repo लेन-देन और संयोज्य Ecto.Multi संरचना का उपयोग करके कई डेटाबेस कार्रवाइयों को परमाण्विक इकाइयों में समूहित करें।

पाठ 4, कुल 4 में से13 चरण

लेन-देन और Ecto.Multi, CoddyKit पर Elixir और Phoenix: स्केलेबल बैकएंड विकास का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Elixir और Phoenix: स्केलेबल बैकएंड विकास सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Elixir और Phoenix: स्केलेबल बैकएंड विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

लेन-देन क्यों

लेन-देन कई कार्रवाइयों को एक साथ बाँधता है, ताकि वे या तो सभी सफल हों या सभी एक साथ वापस पलट दिए जाएँ और डेटा सुसंगत बना रहे।

फ़ंक्शन के साथ Repo.transaction

सबसे सरल रूप एक फ़ंक्शन चलाता है; यदि फ़ंक्शन सामान्य रूप से लौटता है, तो लेन-देन प्रतिबद्ध हो जाता है, और यदि वह अपवाद उत्पन्न करता है, तो लेन-देन वापस पलट दिया जाता है।

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

मैन्युअल रोलबैक

फ़ंक्शन के भीतर आप Repo.rollback/1 के साथ स्पष्ट रूप से प्रक्रिया रोक सकते हैं, जो {:error, reason} लौटाता है।

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

नेस्टेड फ़ंक्शनों की समस्या

जब चरण पहले के परिणामों पर निर्भर हों, तो फ़ंक्शन-आधारित लेन-देन को पढ़ना और दोबारा उपयोग करना कठिन हो जाता है। Ecto.Multi इस समस्या को घोषणात्मक तरीके से हल करता है।

Ecto.Multi बनाना

Ecto.Multi एक ऐसी संरचना है, जो नामित कार्रवाइयों को संचित करती है और run होने तक डेटाबेस को नहीं छूती।

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

कार्रवाइयों को क्रम से जोड़ना

हर कार्रवाई को एक अद्वितीय नाम मिलता है, जिससे आप पहले के परिणामों का संदर्भ दे सकते हैं और बाद में उनका निरीक्षण कर सकते हैं।

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

पहले के चरणों पर निर्भर होना

पिछले चरणों के परिणामों का उपयोग करने के लिए एक फ़ंक्शन दें। इसे repo और पूरी हो चुकी कार्रवाइयों के मानचित्र मिलते हैं।

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

Multi चलाना

Repo.transaction/1 पूरे Multi को परमाणु रूप से चलाता है और {:ok, results} या कोई त्रुटि टपल लौटाता है।

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

विफलताओं का सटीक पता लगाना

विफलता होने पर त्रुटि टपल ठीक-ठीक बताता है कि कौन-सा चरण विफल हुआ और अब तक किए गए कौन-से बदलाव वापस पलट दिए गए।

{:error, :profile, changeset, _changes_so_far}

अन्य Multi कार्रवाइयाँ

Multi update, delete, update_all और delete_all का समर्थन करता है, जो Repo फ़ंक्शनों के अनुरूप हैं।

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

संयोजनीयता के लाभ

क्योंकि Multi केवल डेटा है, आप इसे अलग-अलग फ़ंक्शनों में हिस्सों के रूप में बना सकते हैं और चलाने से पहले इसमें और चरण जोड़ सकते हैं, जिससे परीक्षण करना आसान हो जाता है।

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

त्वरित जाँच

लेन-देन के अपने ज्ञान की जाँच करें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने डेटाबेस बदलावों को परमाणु बनाया:

फ़ंक्शन के साथ Repo.transaction बदलावों को एक साथ प्रतिबद्ध करता है या वापस पलट देता है
Repo.rollback स्पष्ट रूप से प्रक्रिया रोकता है
Ecto.Multi नामित चरणों को डेटा के रूप में संयोजित करता है
विफलताएँ विफल चरण का नाम लौटाती हैं और सब कुछ वापस पलट देती हैं

शुरुआत निःशुल्क

एआई शिक्षक के साथ Elixir सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “लेन-देन और Ecto.Multi” पाठ निःशुल्क है?

हाँ—“लेन-देन और Ecto.Multi” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Elixir और Phoenix: स्केलेबल बैकएंड विकास पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Elixir और Phoenix: स्केलेबल बैकएंड विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“लेन-देन और Ecto.Multi” में मैं क्या सीखूँगा?

Repo लेन-देन और संयोज्य Ecto.Multi संरचना का उपयोग करके कई डेटाबेस कार्रवाइयों को परमाण्विक इकाइयों में समूहित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Elixir और Phoenix: स्केलेबल बैकएंड विकास का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Elixir और Phoenix: स्केलेबल बैकएंड विकास शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Elixir और Phoenix: स्केलेबल बैकएंड विकास शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“लेन-देन और Ecto.Multi” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Elixir और Phoenix: स्केलेबल बैकएंड विकास पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Elixir और Phoenix: स्केलेबल बैकएंड विकास पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Elixir और Phoenix: स्केलेबल बैकएंड विकास पर वापस जाएँ