Erlang 21 - 4. Build a Mnesia Database

4 एक Mnesia डेटाबेस बनाएँ




erlang

4 एक Mnesia डेटाबेस बनाएँ

यह खंड मूल चरणों का वर्णन करता है जब Mnesia डेटाबेस को डिज़ाइन करना और प्रोग्रामर को अलग-अलग समाधान उपलब्ध कराने वाले प्रोग्रामिंग कंस्ट्रक्शन। निम्नलिखित विषयों में शामिल हैं:

  • एक स्कीमा परिभाषित करें
  • डेटा मॉडल
  • Mnesia शुरू करें
  • टेबल बनाएं

4.1 स्कीमा को परिभाषित करें

एक Mnesia प्रणाली का विन्यास एक स्कीमा में वर्णित है। स्कीमा एक विशेष तालिका है जिसमें तालिका के नाम और प्रत्येक तालिका के भंडारण प्रकार (जैसे कि क्या एक तालिका को रैम में संग्रहीत किया जाना है, डिस्क पर, या दोनों, साथ ही साथ इसके स्थान) जैसी जानकारी शामिल है।

डेटा तालिकाओं के विपरीत, इस अनुभाग में वर्णित स्कीमा-संबंधित कार्यों का उपयोग करके स्कीमा तालिकाओं में जानकारी को केवल एक्सेस और संशोधित किया जा सकता है।

Mnesia में डेटाबेस स्कीमा को परिभाषित करने के लिए विभिन्न कार्य हैं। तालिकाओं को स्थानांतरित या हटाया जा सकता है, और तालिका लेआउट को पुन: कॉन्फ़िगर किया जा सकता है।

इन कार्यों का एक महत्वपूर्ण पहलू यह है कि सिस्टम एक तालिका तक पहुंच सकता है जबकि इसे पुन: कॉन्फ़िगर किया जा रहा है। उदाहरण के लिए, तालिका को स्थानांतरित करना संभव है और साथ ही उसी तालिका में लेखन संचालन करना। यह सुविधा उन अनुप्रयोगों के लिए आवश्यक है जिन्हें निरंतर सेवा की आवश्यकता होती है।

यह खंड स्कीमा प्रबंधन के लिए उपलब्ध कार्यों का वर्णन करता है, जो सभी निम्नलिखित ट्यूपलों में से एक हैं:

  • {atomic, ok} यदि सफल हो
  • {aborted, Reason} यदि असफल हो

स्कीमा कार्य

स्कीमा फ़ंक्शन निम्नानुसार हैं:

  • mnesia:create_schema(NodeList) एक नया, खाली स्कीमा प्रारंभ करता है। Mnesia शुरू करने से पहले यह एक अनिवार्य आवश्यकता है। Mnesia एक सही मायने में वितरित DBMS है और स्कीमा एक सिस्टम टेबल है जिसे Mnesia सिस्टम में सभी नोड्स पर दोहराया जाता है। यदि NodeList में कोई भी नोड पर स्कीमा पहले से मौजूद है, तो यह फ़ंक्शन विफल हो NodeList । फ़ंक्शन को Mnesia को पैरामीटर NodeList में निहित सभी db_nodes पर रोकना आवश्यक है। एप्लिकेशन इस फ़ंक्शन को केवल एक बार कॉल करते हैं, क्योंकि यह आमतौर पर एक नए डेटाबेस को प्रारंभ करने के लिए एक बार की गतिविधि है।
  • mnesia:delete_schema(DiscNodeList) किसी भी पुराने स्कीमा को DiscNodeList में नोड पर मिटा देता है। यह सभी डेटा के साथ सभी पुराने तालिकाओं को भी हटाता है। इस फ़ंक्शन के लिए Mnesia को सभी db_nodes पर db_nodes
  • mnesia:delete_table(Tab) टेबल Tab सभी प्रतिकृतियों को स्थायी रूप से हटा देता है।
  • mnesia:clear_table(Tab) टेबल Tab सभी प्रविष्टियों को स्थायी रूप से हटा देता है।
  • mnesia:move_table_copy(Tab, From, To) नोड From तालिका Tab की प्रतिलिपि को नोड From स्थानांतरित करता है। तालिका संग्रहण प्रकार {type} संरक्षित है, इसलिए यदि RAM तालिका को एक नोड से दूसरे नोड में ले जाया जाता है, तो यह नए नोड पर RAM तालिका बनी रहती है। अन्य लेनदेन अभी भी तालिका में पढ़ने और लिखने का कार्य कर सकते हैं जबकि इसे स्थानांतरित किया जा रहा है।
  • mnesia:add_table_copy(Tab, Node, Type) नोड Node पर टेबल Tab की प्रतिकृति बनाता है। तर्क Type या तो परमाणुओं ram_copies , disc_copies , या disc_only_copies । यदि आप एक नोड में सिस्टम टेबल schema की एक प्रति जोड़ते हैं, तो आप चाहते हैं कि Mnesia स्कीमा वहां भी निवास करे। यह क्रिया नोड्स के सेट को विस्तारित करती है, जिसमें इस विशेष Mnesia प्रणाली शामिल है।
  • mnesia:del_table_copy(Tab, Node) नोड Node पर टेबल Tab की प्रतिकृति को हटाता है। जब किसी तालिका की अंतिम प्रतिकृति हटा दी जाती है, तो तालिका हटा दी जाती है।
  • mnesia:transform_table(Tab, Fun, NewAttributeList, NewRecordName) टेबल Tab में सभी रिकॉर्ड्स पर प्रारूप को बदलता है। यह तालिका में सभी रिकॉर्ड के लिए तर्क Fun लागू करता है। Fun एक फ़ंक्शन होना चाहिए जो पुराने प्रकार का रिकॉर्ड लेता है, और नए प्रकार का रिकॉर्ड लौटाता है। तालिका कुंजी को परिवर्तित नहीं किया जाना चाहिए।

    उदाहरण:

    -record(old, {key, val}).
    -record(new, {key, val, extra}).
    
    Transformer =
       fun(X) when record(X, old) ->
          #new{key = X#old.key,
               val = X#old.val,
               extra = 42}
       end,
    {atomic, ok} = mnesia:transform_table(foo, Transformer,
                                          record_info(fields, new),
                                          new),

    तर्क Fun भी परमाणु की ignore हो सकती है, जो इंगित करता है कि तालिका के बारे में केवल मेटाडेटा अपडेट किया गया है। ignore का उपयोग करने की अनुशंसा नहीं की जाती है (क्योंकि यह मेटाडेटा और वास्तविक डेटा के बीच असंगतता पैदा करता है) लेकिन यह उपयोगकर्ता द्वारा स्वयं (ऑफ़लाइन) परिवर्तन करने की संभावना के रूप में शामिल है।

  • change_table_copy_type(Tab, Node, ToType) एक तालिका के संग्रहण प्रकार को बदलता है। उदाहरण के लिए, नोड के रूप में निर्दिष्ट नोड में एक RAM तालिका एक disc_table में बदल जाती है।

4.2 डेटा मॉडल

Mnesia द्वारा नियोजित डेटा मॉडल एक विस्तारित रिलेशनल डेटा मॉडल है। डेटा को तालिकाओं के एक सेट के रूप में व्यवस्थित किया जाता है और विभिन्न डेटा रिकॉर्ड के बीच संबंधों को वर्णित करते हुए अधिक तालिकाओं के रूप में मॉडल किया जा सकता है। प्रत्येक तालिका में एर्लांग रिकॉर्ड के उदाहरण हैं। अभिलेखों को एर्लांग टुपल्स के रूप में दर्शाया गया है।

प्रत्येक ऑब्जेक्ट आइडेंटिफ़ायर (OID) एक टेबल नेम और एक की से बना होता है। उदाहरण के लिए, यदि एक कर्मचारी रिकॉर्ड को टपल {employee, 104732, klacke, 7, male, 98108, {221, 015}} द्वारा दर्शाया गया है, तो इस रिकॉर्ड में एक OID है, जो टपल है {employee, 104732}

इस प्रकार, प्रत्येक तालिका अभिलेखों से बनी होती है, जहां पहला तत्व एक रिकॉर्ड नाम होता है और तालिका का दूसरा तत्व एक कुंजी होता है, जो उस तालिका में विशेष रिकॉर्ड की पहचान करता है। तालिका नाम और एक कुंजी का संयोजन एक धमनी दो नलिका है {Tab, Key} जिसे ओआईडी कहा जाता है। रिलेशनशिप के बारे में अधिक जानकारी के लिए रिकॉर्ड नाम और टेबल के नाम को देखें, Record Names versus Table Names

Mnesia डेटा मॉडल क्या बनाता है एक विस्तारित रिलेशनल मॉडल विशेषता फ़ील्ड में मनमाना Erlang शब्दों को संग्रहीत करने की क्षमता है। एक विशेषता मूल्य, उदाहरण के लिए, अन्य तालिकाओं में अन्य शर्तों के लिए अग्रणी OIDs का एक पूरा पेड़ हो सकता है। इस प्रकार का रिकॉर्ड पारंपरिक संबंधपरक डीबीएमएस में बनाना कठिन है।

4.3 प्रारंभ मानेसिया

Mnesia शुरू करने से पहले, निम्नलिखित कार्य करना चाहिए:

  • एक खाली स्कीमा को सभी भाग लेने वाले नोड्स पर आरंभीकृत किया जाना चाहिए।
  • एर्लैंग सिस्टम शुरू किया जाना चाहिए।
  • डिस्क डेटाबेस स्कीमा वाले नोड्स को फंक्शन mnesia:create_schema(NodeList) साथ परिभाषित और कार्यान्वित किया जाना चाहिए mnesia:create_schema(NodeList)

दो या अधिक भाग लेने वाले नोड्स के साथ एक वितरित सिस्टम चलाते समय, फ़ंक्शन mnesia:start() को प्रत्येक भाग लेने वाले नोड पर निष्पादित किया जाना चाहिए। यह आमतौर पर एक एम्बेडेड वातावरण में बूट स्क्रिप्ट का हिस्सा होगा। एक परीक्षण वातावरण या एक इंटरेक्टिव वातावरण में, mnesia:start() उपयोग या तो mnesia:start() शेल या किसी अन्य प्रोग्राम से भी किया जा सकता है।

एक स्कीम और स्टार्ट मेन्शिया शुरू करें

आइए उदाहरण डेटाबेस Company उपयोग करें, जो दो अलग-अलग नोड्स पर एक डेटाबेस को चलाने के लिए Getting Started करने में वर्णित है, जिसे [email protected] और [email protected] कहा जाता [email protected] । इन नोड्स में से प्रत्येक में Mnesia डायरेक्टरी होनी चाहिए और Mnesia शुरू होने से पहले एक आरंभिक स्कीमा होना चाहिए। Mnesia निर्देशिका का उपयोग करने के लिए निर्दिष्ट करने के दो तरीके हैं:

  • Mnesia शेल शुरू करने या एप्लिकेशन स्क्रिप्ट में या तो एप्लिकेशन पैरामीटर प्रदान करके Mnesia निर्देशिका निर्दिष्ट करें। पहले, निम्न उदाहरण का उपयोग Company डेटाबेस के लिए निर्देशिका बनाने के लिए किया गया था:

    %erl -mnesia dir '"/ldisc/scratch/Mnesia.Company"'
              
  • यदि कोई कमांड-लाइन ध्वज दर्ज नहीं किया गया है, तो Mnesia निर्देशिका उस नोड पर वर्तमान कार्यशील निर्देशिका बन जाती है जहां Erlang शेल प्रारंभ किया गया है।

Company डेटाबेस को शुरू करने और इसे दो निर्दिष्ट नोड पर चलाने के लिए, निम्नलिखित कमांड दर्ज करें:

जैसा कि चित्रित किया गया है, दो निर्देशिकाएं अलग-अलग नोड्स पर रहती हैं, क्योंकि /ldisc/scratch ("स्थानीय" डिस्क) दो अलग-अलग नोड्स पर मौजूद हैं।

इन आदेशों को निष्पादित करके, दो Erlang नोड्स Company डेटाबेस को चलाने के लिए कॉन्फ़िगर किए गए हैं, और इसलिए, डेटाबेस को इनिशियलाइज़ करते हैं। यह स्थापित करते समय केवल एक बार आवश्यक है। अगली बार जब सिस्टम चालू होता है, तो डिस्क से सिस्टम को इनिशियलाइज़ करने के लिए mnesia:start() को दोनों नोड्स पर बुलाया जाता है।

Mnesia नोड्स की एक प्रणाली में, प्रत्येक नोड को सभी तालिकाओं के वर्तमान स्थान के बारे में पता है। इस उदाहरण में, डेटा को नोड्स और फ़ंक्शंस दोनों पर दोहराया जाता है जो टेबलों में डेटा को हेरफेर करने पर दोनों नोड्स में से किसी एक पर निष्पादित किया जा सकता है। कोड, जो Mnesia डेटा में हेरफेर करता है, जहां डेटा रहता है, वहां की परवाह किए बिना समान व्यवहार करता है।

फंक्शन mnesia:stop() Mnesia को नोड पर रोक देता है जहां फंक्शन निष्पादित होता है। फंक्शन mnesia:start/0 और mnesia:stop/0 "लोकल" Mnesia सिस्टम पर काम करते हैं। कोई फ़ंक्शन नोड्स का एक सेट शुरू या बंद नहीं करता है।

स्टार्टअप प्रक्रिया

निम्नलिखित फ़ंक्शन को कॉल करके Mnesia शुरू करें:

mnesia:start().

यह फ़ंक्शन स्थानीय रूप से DBMS आरंभ करता है।

कॉन्फ़िगरेशन की पसंद तालिकाओं के स्थान और लोड क्रम को बदल देती है। विकल्प निम्नानुसार हैं:

  • टेबल्स जिन्हें केवल स्थानीय रूप से संग्रहीत किया जाता है, उन्हें स्थानीय Mnesia निर्देशिका से आरंभ किया जाता है।
  • स्थानीय और साथ ही कहीं और निवास करने वाली प्रतिकृति तालिकाएँ या तो डिस्क से आरंभ की जाती हैं या अन्य नोड से पूरी तालिका की प्रतिलिपि बनाकर, जिसके आधार पर विभिन्न प्रतिकृतियां सबसे हाल ही में होती हैं। Mnesia यह निर्धारित करता है कि सबसे हाल ही में कौन सी मेजें हैं।
  • दूरस्थ नोड पर निवास करने वाली तालिकाएँ लोड होते ही अन्य नोड्स के लिए उपलब्ध होती हैं।

तालिका आरंभीकरण अतुल्यकालिक है। फ़ंक्शन कॉल mnesia:start() परमाणु को वापस लौटाता है और फिर अलग-अलग तालिकाओं को प्रारंभ करने के लिए शुरू होता है। डेटाबेस के आकार के आधार पर, इसमें कुछ समय लग सकता है, और एप्लिकेशन प्रोग्रामर को उन तालिकाओं का इंतजार करना चाहिए, जिनका उपयोग करने से पहले उन्हें एप्लिकेशन की आवश्यकता होती है। यह फंक्शन mnesia:wait_for_tables(TabList, Timeout) का उपयोग करके हासिल किया जाता है, जो तब तक कॉलर को निलंबित कर देता है जब तक TabList में निर्दिष्ट सभी तालिकाओं को ठीक से शुरू नहीं किया जाता है।

यदि एक नोड पर एक प्रतिकृति तालिका शुरू की गई है, तो एक समस्या उत्पन्न हो सकती है, लेकिन Mnesia ने कहा कि स्थानीय नोड पर मौजूद प्रतिकृति की तुलना में एक और (दूरस्थ) प्रतिकृति अधिक हाल ही में है, और आरंभीकरण प्रक्रिया आगे नहीं बढ़ती है। इस स्थिति में, mnesia:wait_for_tables/2 लिए एक कॉल mnesia:wait_for_tables/2 , तब तक कॉलर को निलंबित कर देता है जब तक कि दूरस्थ नोड ने अपने स्थानीय डिस्क से तालिका को प्रारंभ नहीं किया है और नोड ने नेटवर्क पर तालिका को स्थानीय नोड पर कॉपी किया है।

हालाँकि, यह प्रक्रिया समय लेने वाली हो सकती है, शॉर्टकट फंक्शन mnesia:force_load_table(Tab) डिस्क से सभी तालिकाओं को तेज दर पर लोड करता है। फ़ंक्शन नेटवर्क स्थिति की परवाह किए बिना तालिका को डिस्क से लोड करने के लिए मजबूर करता है।

इस प्रकार, यह माना जा सकता है कि यदि कोई अनुप्रयोग तालिका a और b का उपयोग करना चाहता है, तो अनुप्रयोग को तालिकाओं का उपयोग करने से पहले निम्न के समान कुछ क्रिया करनी चाहिए:

case mnesia:wait_for_tables([a, b], 20000) of
  {timeout,   RemainingTabs} ->
    panic(RemainingTabs);
  ok ->
    synced
end.
चेतावनी

जब टेबल को स्थानीय डिस्क से जबरदस्ती लोड किया जाता है, तो स्थानीय नोड डाउन होने के दौरान सभी ऑपरेशन जो प्रतिकृति तालिका पर किए गए थे, और दूरस्थ प्रतिकृति जीवित थी, खो गए हैं। इससे डेटाबेस असंगत हो सकता है।

यदि स्टार्टअप प्रक्रिया विफल हो जाती है, तो फंक्शन mnesia:start() क्रिप्टिक टपल {error,{shutdown, {mnesia_sup,start_link,[normal,[]]}}} । प्रारंभ विफलता के बारे में अधिक जानकारी प्राप्त करने के लिए, कमांड-लाइन तर्कों का उपयोग करें। -boot start_sasl स्क्रिप्ट के तर्क के रूप में -boot start_sasl

4.4 तालिकाएँ बनाएँ

फ़ंक्शन mnesia:create_table(Name, ArgList) टेबल बनाता है। इस फ़ंक्शन को निष्पादित करते समय, यह निम्न में से एक प्रतिक्रिया देता है:

  • {atomic, ok} यदि फ़ंक्शन सफलतापूर्वक निष्पादित होता है
  • फ़ंक्शन {aborted, Reason}

फ़ंक्शन तर्क निम्नानुसार हैं:

  • Name तालिका का Name है। यह आमतौर पर तालिका के गठन के रिकॉर्ड के नाम के समान है। विवरण के लिए, record_name देखें।
  • ArgList {Key,Value} tuples की एक सूची है। निम्नलिखित तर्क मान्य हैं:

    • {type, Type} , जहाँ Type या तो परमाणुओं के set होना चाहिए, ordered_set , या bag । डिफ़ॉल्ट set

      ध्यान दें कि वर्तमान में ordered_set disc_only_copies तालिकाओं के लिए समर्थित नहीं है।

      टाइप set या ordered_set की तालिका में प्रति कुंजी शून्य या एक रिकॉर्ड होता है, जबकि टाइप bag की तालिका में प्रति कुंजी रिकॉर्ड की एक मनमानी संख्या हो सकती है। प्रत्येक रिकॉर्ड की कुंजी हमेशा रिकॉर्ड की पहली विशेषता होती है।

      निम्न उदाहरण प्रकार set और bag बीच के अंतर को दर्शाता है:

      f() ->
         F = fun() ->
               mnesia:write({foo, 1, 2}),
               mnesia:write({foo, 1, 3}),
               mnesia:read({foo, 1})
             end,
         mnesia:transaction(F).

      यह लेन-देन सूची [{foo,1,3}] लौटाता है यदि टेबल foo टाइप set । हालाँकि, सूची [{foo,1,2}, {foo,1,3}] लौटा दी गई है यदि तालिका प्रकार के bag

      Mnesia टेबल में कभी भी एक ही तालिका में एक ही रिकॉर्ड के डुप्लिकेट नहीं हो सकते हैं। डुप्लिकेट रिकॉर्ड में समान सामग्री और कुंजी के साथ विशेषताएँ हैं।

    • {disc_copies, NodeList} , जहां NodeList नोड्स की एक सूची है जहां डिस्क पर निवास करने के लिए यह तालिका है।

      प्रकार की तालिका प्रतिकृति के लिए लिखें लिखें disc_copies डिस्क कॉपी और तालिका की रैम कॉपी में डेटा लिखते हैं।

      एक नोड पर एक प्रकार की disc_copies की प्रतिकृति तालिका होना संभव है, और उसी तालिका को दूसरे नोड पर एक अलग प्रकार के रूप में संग्रहीत किया जाता है। डिफ़ॉल्ट [] । निम्नलिखित परिचालन विशेषताओं की आवश्यकता होने पर यह व्यवस्था वांछनीय है:

      • पढ़ें ऑपरेशन तेज होना चाहिए और रैम में प्रदर्शन किया जाना चाहिए।
      • सभी लेखन कार्यों को निरंतर भंडारण के लिए लिखा जाना चाहिए।

      एक disc_copies टेबल प्रतिकृति पर एक disc_copies ऑपरेशन दो चरणों में किया जाता है। पहले राइट ऑपरेशन को लॉग फ़ाइल में जोड़ा जाता है, फिर वास्तविक ऑपरेशन रैम में किया जाता है।

    • {ram_copies, NodeList} , जहां NodeList नोड्स की एक सूची है जहां यह तालिका रैम में संग्रहीत है। डिफ़ॉल्ट [node()] । यदि डिफ़ॉल्ट मान का उपयोग तालिका बनाने के लिए किया जाता है, तो यह केवल स्थानीय नोड पर स्थित है।

      प्रकार के टेबल प्रतिकृतियां ram_copies को फंक्शन mnesia:dump_tables(TabList) साथ डिस्क में डंप किया जा सकता है mnesia:dump_tables(TabList)

    • {disc_only_copies, NodeList} । ये तालिका प्रतिकृतियां केवल डिस्क पर संग्रहीत की जाती हैं और इसलिए उपयोग करने के लिए धीमी होती हैं। हालांकि, एक डिस्क-केवल प्रतिकृति अन्य दो संग्रहण प्रकारों की तालिका प्रतिकृति की तुलना में कम मेमोरी का उपभोग करती है।
    • {index, AttributeNameList} , जहां AttributeNameList परमाणुओं की एक सूची है, जो Mnesia को बनाने और बनाए रखने के लिए विशेषताओं के नामों को निर्दिष्ट करता है। सूची में प्रत्येक तत्व के लिए एक सूचकांक तालिका मौजूद है। Mnesia रिकॉर्ड का पहला क्षेत्र कुंजी है और इस प्रकार किसी भी अतिरिक्त सूचकांक की आवश्यकता नहीं है।

      एक रिकॉर्ड का पहला क्षेत्र टपल का दूसरा तत्व है, जो रिकॉर्ड का प्रतिनिधित्व है।

    • {snmp, SnmpStruct} SnmpStruct SNMP उपयोगकर्ता के गाइड में वर्णित है। मूल रूप से, यदि यह विशेषता ArgList के mnesia:create_table/2 में मौजूद है mnesia:create_table/2 , तालिका तुरंत SNMP तक पहुँच योग्य है।

      सिस्टम को हेरफेर करने और नियंत्रित करने के लिए एसएनएमपी का उपयोग करने वाले अनुप्रयोगों को डिजाइन करना आसान है। Mnesia तार्किक तालिकाओं के बीच एक सीधा मानचित्रण प्रदान करता है जो एक SNMP नियंत्रण अनुप्रयोग और एक Mnesia तालिका बनाता है जो भौतिक डेटा बनाता है। डिफ़ॉल्ट मान []

    • {local_content, true} । जब किसी एप्लिकेशन को एक ऐसी तालिका की आवश्यकता होती है, जिसकी सामग्री प्रत्येक नोड पर स्थानीय रूप से विशिष्ट हो, तो local_content टेबल का उपयोग किया जा सकता है। तालिका का नाम सभी Mnesia नोड्स के लिए जाना जाता है, लेकिन इसकी सामग्री प्रत्येक नोड के लिए अद्वितीय है। इस प्रकार की तालिका का उपयोग स्थानीय स्तर पर किया जाना चाहिए।
    • {attributes, AtomList} उन अभिलेखों के लिए विशेषता नामों की एक सूची है जो तालिका को आबाद करने वाले हैं। डिफ़ॉल्ट सूची [key, val] । तालिका में कुंजी के अलावा कम से कम एक अतिरिक्त विशेषता होनी चाहिए। रिकॉर्ड में एकल विशेषताओं तक पहुँचने के दौरान, परमाणुओं के रूप में विशेषता नामों को हार्ड कोड करने की अनुशंसा नहीं की जाती है। इसके बजाय निर्माण record_info(fields, record_name) उपयोग करें।

      अभिव्यक्ति record_info(fields, record_name) को record_info(fields, record_name) प्रीप्रोसेसर द्वारा संसाधित किया जाता है और रिकॉर्ड फ़ील्ड नामों की एक सूची देता है। रिकॉर्ड परिभाषा के साथ -record(foo, {x,y,z}). अभिव्यक्ति record_info(fields,foo) को सूची [x,y,z] विस्तारित किया गया है। इसलिए आपके लिए विशेषता नाम प्रदान करना या record_info/2 संकेतन का उपयोग करना record_info/2 है।

      यह record_info/2 संकेतन का उपयोग करने के लिए अनुशंसित है, क्योंकि कार्यक्रम को बनाए रखना आसान हो जाता है और भविष्य के रिकॉर्ड परिवर्तनों के संबंध में कार्यक्रम अधिक मजबूत हो जाता है।

    • {record_name, Atom} तालिका में संग्रहीत सभी रिकॉर्ड के सामान्य नाम को निर्दिष्ट करता है। तालिका में संग्रहीत सभी अभिलेखों में यह नाम उनके पहले तत्व के रूप में होना चाहिए। तालिका के नाम के लिए record_name डिफॉल्ट करता है। अधिक जानकारी के लिए, Record Names versus Table Names

एक उदाहरण के रूप में, निम्नलिखित रिकॉर्ड परिभाषा पर विचार करें:

-record(funky, {x, y}).

निम्न कॉल दो नोड्स पर प्रतिकृति की गई तालिका बनाएगी, जिसमें विशेषता y पर एक अतिरिक्त अनुक्रमणिका होती है, और एक प्रकार का bag

mnesia:create_table(funky, [{disc_copies, [N1, N2]}, {index,
[y]}, {type, bag}, {attributes, record_info(fields, funky)}]).

जबकि निम्नलिखित डिफ़ॉल्ट कोड मूल्यों के लिए एक कॉल स्थानीय नोड पर एक रैम कॉपी के साथ एक तालिका लौटाएगा, कोई अतिरिक्त अनुक्रमित नहीं होगा, और विशेषताओं को सूची [key,val] डिफ़ॉल्ट रूप से रखा जाएगा।

mnesia:create_table(stuff, [])