Erlang 21

mnesia




erlang

mnesia

मॉड्यूल

mnesia

मॉड्यूल सारांश

एक वितरित दूरसंचार डीबीएमएस

विवरण

Mnesia द्वारा प्रदान की जाने वाली सबसे महत्वपूर्ण और आकर्षक क्षमताएं निम्नलिखित हैं:

  • एक रिलेशनल / ऑब्जेक्ट हाइब्रिड डेटा मॉडल जो दूरसंचार अनुप्रयोगों के लिए उपयुक्त है।
  • एक DBMS क्वेरी भाषा, क्वेरी सूची समझ (QLC) एक ऐड-ऑन लाइब्रेरी के रूप में।
  • हठ। तालिकाओं को सुसंगत रूप से डिस्क और मुख्य मेमोरी में रखा जा सकता है।
  • प्रतिकृति। टेबल्स को कई नोड्स पर दोहराया जा सकता है।
  • परमाणु लेनदेन। टेबल हेरफेर संचालन की एक श्रृंखला को एकल परमाणु लेनदेन में वर्गीकृत किया जा सकता है।
  • स्थान पारदर्शिता। कार्यक्रमों को वास्तविक डेटा स्थान के ज्ञान के बिना लिखा जा सकता है।
  • बहुत तेजी से वास्तविक समय डेटा खोज।
  • स्कीमा हेरफेर दिनचर्या। DBMS को सिस्टम को बिना रुके रनटाइम पर फिर से जोड़ा जा सकता है।

यह संदर्भ मैनुअल मेन्सिया एपीआई का वर्णन करता है। इसमें Mnesia तालिकाओं को परिभाषित और हेरफेर करने वाले कार्य शामिल हैं।

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

मानेसिया में डेटा तालिकाओं के एक सेट के रूप में आयोजित किया जाता है। प्रत्येक तालिका में एक नाम होता है जो एक परमाणु होना चाहिए। प्रत्येक तालिका Erlang रिकॉर्ड से बनी है। उपयोगकर्ता रिकॉर्ड परिभाषाओं के लिए जिम्मेदार है। प्रत्येक तालिका में गुणों का एक सेट भी होता है। निम्नलिखित कुछ गुण हैं जो प्रत्येक तालिका से जुड़े हैं:

  • type । प्रत्येक तालिका में set , ordered_set या bag शब्दार्थ हो सकते हैं। ध्यान दें कि वर्तमान में ordered_set लिए समर्थित नहीं है।

    यदि तालिका प्रकार set , तो प्रत्येक कुंजी एक या शून्य रिकॉर्ड की ओर ले जाती है।

    यदि एक नया आइटम मौजूदा रिकॉर्ड के समान कुंजी के साथ डाला जाता है, तो पुराना रिकॉर्ड ओवरराइट किया जाता है। हालाँकि, यदि कोई तालिका प्रकार के bag , तो प्रत्येक कुंजी कई रिकॉर्ड के लिए मैप कर सकती है। टाइप bag टेबल में सभी रिकॉर्ड अद्वितीय हैं, केवल चाबियों को दोहराया जा सकता है।

  • record_name । तालिका में संग्रहीत सभी अभिलेखों का नाम समान होना चाहिए। रिकॉर्ड एक ही रिकॉर्ड प्रकार के उदाहरण होने चाहिए।

  • ram_copies । एक तालिका को कई एर्लांग नोड्स पर दोहराया जा सकता है। प्रॉपर्टी ram_copies Erlang नोड्स की एक सूची निर्दिष्ट करती है जहां RAM प्रतियां रखी जाती हैं। इन प्रतियों को नियमित अंतराल पर डिस्क में डाला जा सकता है। हालाँकि, लेन-देन के आधार पर इन प्रतियों के अपडेट डिस्क पर नहीं लिखे जाते हैं।

  • disc_copies यह संपत्ति Erlang नोड्स की एक सूची निर्दिष्ट करती है जहां तालिका को रैम और डिस्क पर रखा जाता है। तालिका के सभी अपडेट वास्तविक तालिका में किए जाते हैं और डिस्क में भी लॉग इन होते हैं। यदि एक तालिका एक निश्चित नोड में disc_copies प्रकार की है, तो पूरी तालिका रैम मेमोरी में और डिस्क पर निवासी है। तालिका में किया गया प्रत्येक लेनदेन एक LOG फ़ाइल में जोड़ा जाता है और रैम तालिका में लिखा जाता है।

  • disc_only_copies । कुछ या सभी, तालिका प्रतिकृतियां केवल डिस्क पर रखी जा सकती हैं। ये प्रतिकृतियां रैम-आधारित प्रतिकृतियों की तुलना में काफी धीमी हैं।

  • index । यह विशेषता नामों, या पूर्णांकों की एक सूची है, जो टपल पदों को निर्दिष्ट करता है, जिस पर Mnesia एक अतिरिक्त सूचकांक तालिका का निर्माण और रखरखाव करना है।

  • local_content । जब किसी एप्लिकेशन को उन तालिकाओं की आवश्यकता होती है जिनकी सामग्री प्रत्येक नोड के लिए स्थानीय होती है, तो local_content टेबल का उपयोग किया जा सकता है। तालिका का नाम सभी मेन्सिया नोड्स के लिए जाना जाता है, लेकिन इसकी सामग्री प्रत्येक नोड पर अद्वितीय है। इसका मतलब है कि ऐसी तालिका तक पहुंच स्थानीय रूप से होनी चाहिए। local_content व्यवहार को सक्षम करने के लिए फ़ील्ड local_content को true पर सेट करें। डिफ़ॉल्ट false

  • majority । यह विशेषता true या false ; डिफ़ॉल्ट false । जब true , तो एक अद्यतन के लिए तालिका की अधिकांश प्रतिकृतियां उपलब्ध होनी चाहिए। मेजरिटी चेकिंग को मिशन-क्रिटिकल डेटा वाली टेबलों पर सक्षम किया जा सकता है, जहाँ नेटवर्क विभाजन के कारण विसंगतियों से बचना महत्वपूर्ण है।

  • snmp । प्रत्येक (सेट-आधारित) मेन्सिया तालिका को स्वचालित रूप से एक साधारण नेटवर्क प्रबंधन प्रोटोकॉल (एसएनएमपी) के रूप में अच्छी तरह से आदेश दिया तालिका में बदल दिया जा सकता है। यह गुण SNMP कुंजियों के प्रकार को निर्दिष्ट करता है।

  • attributes । तालिका में सम्मिलित किए गए अभिलेखों की विशेषताओं के नाम।

तालिका गुणों और उनके विवरणों के पूर्ण सेट के बारे में जानकारी के लिए, mnesia:create_table/2 देखें mnesia:create_table/2

यह संदर्भ मैनुअल विभिन्न उदाहरणों को दर्शाने के लिए व्यक्तियों की एक तालिका का उपयोग करता है। निम्नलिखित रिकॉर्ड परिभाषा मान ली गई है:

-record(person, {name,
                 age = 0,
                 address = unknown,
                 salary = 0,
                 children = []}),

पहला रिकॉर्ड विशेषता प्राथमिक कुंजी है, या शॉर्ट के लिए कुंजी है।

फ़ंक्शन विवरण वर्णानुक्रम में क्रमबद्ध होते हैं। mnesia:create_table/2 बारे में पढ़ना शुरू करने के लिए सिफारिश की जाती है mnesia:create_table/2 , mnesia:lock/2 , और mnesia:activity/4 इससे पहले कि आप जारी रखें और बाकी के बारे में जानें।

लेन-देन-संदर्भ में लिखना या हटाना लेनदेन के दौरान प्रत्येक संशोधित रिकॉर्ड की एक स्थानीय प्रतिलिपि बनाता है। पुनरावृत्ति के दौरान, वह है mnesia:fold[lr]/4 , mnesia:next/2 , mnesia:prev/2 , और mnesia:snmp_get_next_index/2 , Mnesia हर लिखित या हटाए गए रिकॉर्ड के लिए बनाता है, जो प्रदर्शन को कम कर सकता है।

यदि संभव हो, तो तालिका में पुनरावृत्ति करने से पहले उसी लेनदेन में रिकॉर्ड लिखने या हटाने से बचें।

निर्यात

गर्भपात (कारण) -> लेनदेन गर्भपात

लेन-देन को चुपचाप टपल {aborted, Reason} । मनेसिया लेनदेन की समाप्ति का मतलब है कि एक अपवाद को एक संलग्नक catch फेंक दिया गया है। इस प्रकार, अभिव्यक्ति catch mnesia:abort(x) लेनदेन को समाप्त नहीं करता है।

activate_checkpoint (Args) -> {ठीक है, नाम, नोड्स} | {त्रुटि, कारण}

एक चौकी प्रणाली का एक सुसंगत दृश्य है। एक चेकपॉइंट टेबल के एक सेट पर सक्रिय किया जा सकता है। यह चौकी तब पता लगाया जा सकता है और सिस्टम के एक दृश्य को प्रस्तुत करता है क्योंकि यह उस समय मौजूद था जब चेकपॉइंट सक्रिय था, भले ही तालिकाओं को जोड़ दिया गया हो या उसमें हेरफेर किया गया हो।

Args निम्नलिखित ट्यूपल्स की एक सूची है:

  • {name,Name} Name चौकी का नाम है। प्रत्येक चेकपॉइंट में एक नाम होना चाहिए जो संबंधित नोड्स के लिए अद्वितीय है। चेकपॉइंट के निष्क्रिय होने के बाद ही नाम का पुन: उपयोग किया जा सकता है। डिफ़ॉल्ट रूप से, एक नाम जो संभवतः अद्वितीय है, उत्पन्न होता है।

  • {max,MaxTabs} MaxTabs उन टेबल की एक सूची है, जिन्हें चेकपॉइंट में शामिल किया जाना है। डिफ़ॉल्ट [] । इन तालिकाओं के लिए, अतिरेक को अधिकतम किया जाता है और चौकी की जानकारी को सभी प्रतिकृतियों के साथ एक साथ रखा जाता है। यदि तालिकाओं में कई प्रतिकृतियां हैं, तो चेकपॉइंट अधिक सहिष्णु हो जाता है। जब स्कीमा जोड़तोड़ फ़ंक्शन mnesia:add_table_copy/3 द्वारा एक नया प्रतिकृति जोड़ा जाता है mnesia:add_table_copy/3 , एक अनुचर भी स्वचालित रूप से संलग्न होता है।

  • {min,MinTabs} MinTabs उन तालिकाओं की एक सूची है जिन्हें चेकपॉइंट में शामिल किया जाना है। डिफ़ॉल्ट [] है। इन तालिकाओं के लिए, अतिरेक को कम से कम किया जाता है और चेकपॉइंट जानकारी केवल एक प्रतिकृति के साथ बरकरार रखी जाती है, अधिमानतः स्थानीय नोड पर।

  • {allow_remote,Bool} false अर्थ है कि सभी अनुचर स्थानीय होने चाहिए। यदि तालिका स्थानीय रूप से नहीं रहती है, तो चेकपॉइंट सक्रिय नहीं किया जा सकता है। true अनुचर को किसी भी नोड पर आवंटित करने की अनुमति देता है। डिफ़ॉल्ट true

  • {ram_overrides_dump,Bool} । केवल ram_copies लिए लागू है। Bool आपको तालिका स्थिति का चयन करने की अनुमति देता है क्योंकि यह रैम में है, या जैसा कि यह डिस्क पर है। true अर्थ है कि रैम में नवीनतम प्रतिबद्ध रिकॉर्ड चौकी में शामिल किए जाने हैं। ये रिकॉर्ड हैं जो एप्लिकेशन एक्सेस करते हैं। false अर्थ है कि DAT फ़ाइलों में डंप किए गए रिकॉर्ड को चौकी में शामिल किया जाना है। ये रिकॉर्ड स्टार्टअप पर लदे हुए हैं। डिफ़ॉल्ट false

रिटर्न {ok,Name,Nodes} या {error,Reason} Name (संभवतः उत्पन्न) चौकी का नाम है। Nodes हैं जो चेकपॉइंट में शामिल हैं। चेकपॉइंट अनुचर रखने वाले केवल नोड्स चेकपॉइंट के बारे में जानते हैं।

गतिविधि (AccessContext, Fun [, Args]) -> ResultOfFun | बाहर निकलने के (कारण)

mnesia:activity(AccessContext, Fun, Args, AccessMod) , जहां AccessMod mnesia:system_info(access_module) द्वारा प्राप्त डिफ़ॉल्ट एक्सेस कॉलबैक मॉड्यूल है mnesia:system_info(access_module) Args डिफॉल्ट करता है [] (खाली सूची)।

गतिविधि (AccessContext, Fun, Args, AccessMod) -> ResultOfFun | बाहर निकलने के (कारण)

कार्यात्मक वस्तु का Fun तर्क के साथ Fun Args

गतिविधि के अंदर निष्पादित होने वाले कोड में तालिका हेरफेर फ़ंक्शन की एक श्रृंखला शामिल हो सकती है, जो एक AccessContext । वर्तमान में, निम्नलिखित पहुँच संदर्भ समर्थित हैं:

transaction

{transaction, infinity} लिए लघु

{transaction, Retries}

mnesia:transaction(Fun, Args, Retries) कॉल mnesia:transaction(Fun, Args, Retries) । ध्यान दें कि यदि लेन-देन सफल (परमाणु) है, तो Fun से परिणाम लौटा दिया जाता है, अन्यथा फ़ंक्शन एक संक्षिप्त कारण के साथ बाहर निकल जाता है।

sync_transaction

{sync_transaction, infinity} लिए लघु

{sync_transaction, Retries}

mnesia:sync_transaction(Fun, Args, Retries) कॉल mnesia:sync_transaction(Fun, Args, Retries) । ध्यान दें कि यदि लेन-देन सफल (परमाणु) है, तो Fun से परिणाम लौटा दिया जाता है, अन्यथा फ़ंक्शन एक संक्षिप्त कारण के साथ बाहर निकल जाता है।

async_dirty

mnesia:async_dirty(Fun, Args) कॉल mnesia:async_dirty(Fun, Args)

sync_dirty

mnesia:sync_dirty(Fun, Args) कॉल mnesia:sync_dirty(Fun, Args)

ets

mnesia:ets(Fun, Args) कॉल mnesia:ets(Fun, Args)

यह फ़ंक्शन ( mnesia:activity/4 ) फ़ंक्शंस mnesia:transaction से एक महत्वपूर्ण तरीके से भिन्न होता है mnesia:transaction , mnesia:sync_transaction , mnesia:async_dirty , mnesia:sync_dirty , और mnesia:ets । तर्क AccessMod एक कॉलबैक मॉड्यूल का नाम है, जो mnesia_access व्यवहार को लागू करता है।

Mnesia निम्नलिखित कार्यों के लिए कॉल करता है:

  • मेन्सिया: लॉक / 2 (read_lock_table / 1, write_lock_table / 1)
  • मेनेसिया: लिखना / 3 (लिखना / 1, s_write / 1)
  • मेनेसिया: डिलीट / 3 (डिलीट / 1, s_delete / 1)
  • मेनेसिया: delete_object / 3 (delete_object / 1, s_delete_object / 1)
  • मनेसिया: पढ़ें / 3 (पढ़ें / 1, भय / 1)
  • मेनेसिया: match_object / 3 (match_object / 1)
  • mnesia: all_keys / 1
  • mnesia: पहले / 1
  • mnesia: पिछले / 1
  • mnesia: पिछला / 2
  • mnesia: अगले / 2
  • mnesia: index_match_object / 4 (index_match_object / 2)
  • mnesia: index_read / 3
  • mnesia: table_info / 2

इसी के लिए:

  • AccessMod: लॉक (एक्टिविटी, अपारदर्शी, LockItem, LockKind)
  • AccessMod: लिखना (एक्टिविटी, अपारदर्शी, टैब, आरईसी, लॉककिंड)
  • AccessMod: डिलीट (एक्टिविटीआईड, ओपेक, टैब, की, लॉककिंड)
  • AccessMod: delete_object (ActivId, Opaque, Tab, RecXS, LockKind)
  • AccessMod: पढ़ें (एक्टिविटी, अपारदर्शी, टैब, कुंजी, लॉककिंड)
  • AccessMod: match_object (ActivId, Opaque, Tab, Pattern, LockKind)
  • AccessMod: all_keys (एक्टिविटी, अपारदर्शी, टैब, लॉककिंड)
  • AccessMod: पहला (एक्टिविटी, अपारदर्शी, टैब)
  • AccessMod: अंतिम (एक्टिविडी, अपारदर्शी, टैब)
  • AccessMod: prev (एक्टिविटी, अपारदर्शी, टैब, कुंजी)
  • एक्सेसमॉड: नेक्स्ट (एक्टिविटीआईड, ओपेक, टैब, की)
  • AccessMod: index_match_object (ActivId, Opaque, Tab, Pattern, Attr, LockKind)
  • AccessMod: index_read (ActivId, Opaque, Tab, SecondaryKey, Attr, LockKind)
  • AccessMod: table_info (एक्टिविट, अपैक, टैब, इन्फोइटेम)

ActivityId एक रिकॉर्ड है जो संलग्न मनेसिया गतिविधि की पहचान का प्रतिनिधित्व करता है। पहले क्षेत्र ( element(1, ActivityId) साथ प्राप्त) में एक परमाणु होता है, जिसे गतिविधि प्रकार के रूप में व्याख्या किया जा सकता है: ets , async_dirty , sync_dirty , या tid tid मतलब है कि गतिविधि एक लेन-देन है। शेष पहचान रिकॉर्ड की संरचना Mnesia के लिए आंतरिक है।

Opaque एक अपारदर्शी डेटा संरचना है जो Mnesia के लिए आंतरिक है।

add_table_copy (टैब, नोड, प्रकार) -> {निरस्त, R} | {परमाणु, ठीक है}

नोड Node पर तालिका की एक और प्रतिलिपि बनाता है। तर्क Type या तो परमाणुओं ram_copies , disc_copies , या disc_only_copies । उदाहरण के लिए, निम्न कॉल यह सुनिश्चित करती है कि नोड टेबल पर person तालिका की डिस्क प्रतिकृति भी मौजूद है:

mnesia:add_table_copy(person, Node, disc_copies)

इस फ़ंक्शन का उपयोग schema नामक तालिका की प्रतिकृति को जोड़ने के लिए भी किया जा सकता है।

add_table_index (टैब, AttrName) -> {गर्भपात, आर} | {परमाणु, ठीक है}

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

mnesia:add_table_index(person, age)

इंडेक्स मुफ्त में नहीं आते हैं। वे उस स्थान पर कब्जा कर लेते हैं जो तालिका आकार के लिए आनुपातिक है, और वे थोड़ा धीमा निष्पादित करने के लिए तालिका में सम्मिलन का कारण बनते हैं।

all_keys (टैब) -> KeyList | लेन-देन गर्भपात

Tab नाम की सभी कुंजियों की सूची लौटाता है। इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। अधिक जानकारी के लिए, mnesia:activity/4 देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह पूरी तालिका पर एक रीड लॉक प्राप्त करता है।

async_dirty (मज़ा, [, Args]) -> ResultOfFun | बाहर निकलने के (कारण)

Fun को एक ऐसे संदर्भ में कहा जाता है जो लेनदेन द्वारा सुरक्षित नहीं है। Fun में प्रदर्शन किए गए मेन्सिया फ़ंक्शन कॉल को गंदे कार्यों के लिए मैप किया जाता है। इसमें अभी भी लॉगिंग, प्रतिकृति और सदस्यता शामिल हैं, लेकिन इसमें कोई लॉकिंग, स्थानीय लेनदेन संग्रहण या प्रतिबद्ध प्रोटोकॉल शामिल नहीं हैं। चेकपॉइंट रिटेनर्स और इंडेक्स अपडेट किए जाते हैं, लेकिन वे गंदे अपडेट किए जाते हैं। सामान्य mnesia:dirty_* ऑपरेशन, ऑपरेशन अर्ध-अतुल्यकालिक रूप से किए जाते हैं। विवरण के लिए, mnesia:activity/4 देखें mnesia:activity/4 और उपयोगकर्ता की मार्गदर्शिका।

लेन-देन का उपयोग किए बिना Mnesia तालिकाओं में हेरफेर किया जा सकता है। इसके कुछ गंभीर नुकसान हैं, लेकिन यह काफी तेज है, क्योंकि लेन-देन प्रबंधक इसमें शामिल नहीं है और कोई भी लॉक सेट नहीं है। एक गंदा ऑपरेशन, हालांकि, एक निश्चित स्तर की स्थिरता की गारंटी देता है, और गंदा संचालन रिकॉर्ड किए गए रिकॉर्ड को वापस नहीं कर सकता है। सभी गंदे ऑपरेशन प्रोग्रामर को स्थान पारदर्शिता प्रदान करते हैं, और एक प्रोग्राम को कार्य करने के लिए एक निश्चित तालिका के ठिकाने के बारे में पता होना आवश्यक नहीं है।

ध्यान दें कि लेन-देन की तुलना में रिकॉर्ड गंदा पढ़ने के लिए यह दस गुना अधिक कुशल है।

आवेदन के आधार पर, कुछ कार्यों के लिए गंदे कार्यों का उपयोग करना एक अच्छा विचार हो सकता है। लगभग सभी Mnesia फ़ंक्शन जिन्हें लेनदेन के भीतर बुलाया जा सकता है, में एक गंदा समकक्ष होता है, जो बहुत अधिक कुशल होता है।

हालांकि, ध्यान दें कि एक जोखिम है कि डेटाबेस को असंगत स्थिति में छोड़ा जा सकता है यदि इसे अपडेट करने के लिए गंदे संचालन का उपयोग किया जाता है। गंदा ऑपरेशन केवल प्रदर्शन कारणों के लिए उपयोग किया जाना है जब यह बिल्कुल आवश्यक है।

ध्यान दें कि कॉलिंग (नेस्टिंग) mnesia:[a]sync_dirty एक लेन-देन-संदर्भ के अंदर लेनदेन शब्दार्थ विरासत में मिला।

बैकअप (अपारदर्शी [, BackupMod]) -> ठीक | {त्रुटि, कारण}

एक नया चेकपॉइंट सक्रिय करता है जिसमें स्कीमा सहित सभी माया तालिकाएं शामिल हैं, जिसमें अधिकतम डिग्री अतिरेक है, और backup_checkpoint/2/3 का उपयोग करके एक बैकअप करता है। बैकअप कॉलबैक मॉड्यूल BackupMod का डिफ़ॉल्ट मान mnesia:system_info(backup_module) द्वारा प्राप्त किया जाता है।

backup_checkpoint (नाम, अपारदर्शी [, BackupMod]) -> ठीक है | {त्रुटि, कारण}

तालिकाएँ बैकअप मॉड्यूल BackupMod का उपयोग करके बाहरी मीडिया तक समर्थित हैं। स्थानीय सामग्री संपत्ति के साथ तालिकाओं का बैकअप लिया जाता है क्योंकि वे वर्तमान नोड पर मौजूद हैं। BackupMod mnesia:system_info(backup_module) द्वारा प्राप्त डिफ़ॉल्ट बैकअप कॉलबैक मॉड्यूल है। सटीक कॉलबैक इंटरफ़ेस ( mnesia_backup behavior ) के बारे में जानकारी के लिए, उपयोगकर्ता मार्गदर्शिका देखें।

change_config (कॉन्फ़िगरेशन, मान) -> {त्रुटि, कारण} | {ठीक है, रिटर्नवैल्यू}

Config निम्न कॉन्फ़िगरेशन मापदंडों का एक परमाणु होना है:

extra_db_nodes

Value नोड्स की एक सूची है जिसे Mnesia से कनेक्ट करने का प्रयास करना है। ReturnValue में वे नोड्स हैं जिनसे Mnesia जुड़ा हुआ है।

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

ध्यान दें कि मान्सिया रिटर्नवैल्यू में लौटे लोगों की तुलना में अन्य नोड्स से जुड़ा हो सकता है।

dc_dump_limit

Value एक संख्या है। Section Configuration Parameters में विवरण देखें। ReturnValue नया मूल्य है। ध्यान दें कि यह कॉन्फ़िगरेशन पैरामीटर लगातार नहीं है। यह खो जाता है जब मानेसिया बंद हो गया है।

change_table_access_mode (टैब, एक्सेसमोड) -> {निरस्त, R} | {परमाणु, ठीक है}

AcccessMode डिफ़ॉल्ट रूप से परमाणु read_write लेकिन इसे परमाणु read_write पर भी सेट किया जा सकता है। यदि AccessMode को read_only सेट किया read_only , तो टेबल पर अपडेट नहीं किया जा सकता है। स्टार्टअप पर, Mnesia हमेशा स्थानीय और अन्य नोड्स पर समाप्त हो जाने पर, भले ही स्थानीय स्तर पर read_only तालिकाओं को लोड करता हो।

change_table_copy_type (टैब, नोड, टू) -> {निरस्त, R} | {परमाणु, ठीक है}

उदाहरण के लिए:

mnesia:change_table_copy_type(person, node(), disc_copies)

Node में एक डिस्क-आधारित तालिका में रैम तालिका से person तालिका को बदल देता है।

इस फ़ंक्शन का उपयोग schema नामक तालिका के भंडारण प्रकार को बदलने के लिए भी किया जा सकता है। स्कीमा तालिका में स्टोरेज प्रकार के रूप में केवल ram_copies या disc_copies हो सकते हैं। यदि स्कीमा का संग्रहण प्रकार ram_copies , तो उस नोड पर कोई अन्य तालिका डिस्क-निवासी नहीं हो सकती है।

change_table_load_order (टैब, लोडऑर्डर) -> {निरस्त, R} | {परमाणु, ठीक है}

LoadOrder प्राथमिकता डिफ़ॉल्ट 0 (शून्य) द्वारा है, लेकिन इसे किसी भी पूर्णांक पर सेट किया जा सकता है। सबसे अधिक LoadOrder प्राथमिकता वाली तालिकाओं को पहले स्टार्टअप पर लोड किया जाता है।

change_table_majority (टैब, अधिकांश) -> {aborted, R} | {परमाणु, ठीक है}

Majority को एक बूलियन होना चाहिए। डिफ़ॉल्ट false । जब true , तो एक अद्यतन के लिए तालिका की अधिकांश प्रतिकृतियां उपलब्ध होनी चाहिए। जब खंडित तालिकाओं पर उपयोग किया जाता है, तो Tab का आधार तालिका नाम होना चाहिए। व्यक्तिगत टुकड़ों पर बहुमत सेटिंग को सीधे बदलने की अनुमति नहीं है।

clear_table (टैब) -> {निरस्त, R} | {परमाणु, ठीक है}

तालिका Tab में सभी प्रविष्टियाँ हटाता है।

create_schema (DiscNodes) -> ठीक | {त्रुटि, कारण}

डिस्क पर एक नया डेटाबेस बनाता है। प्रत्येक नोड के स्थानीय मेन्सिया निर्देशिका में विभिन्न फाइलें बनाई जाती हैं। ध्यान दें कि प्रत्येक नोड के लिए निर्देशिका अद्वितीय होनी चाहिए। दो नोड्स को एक ही निर्देशिका को कभी भी साझा नहीं करना चाहिए। यदि संभव हो, तो प्रदर्शन को बेहतर बनाने के लिए स्थानीय डिस्क डिवाइस का उपयोग करें।

mnesia:create_schema/1 विफल हो जाता है यदि DiscNodes रूप में दिए गए किसी भी Erlang नोड जीवित नहीं हैं, यदि Mnesia किसी भी नोड पर चल रहा है, या यदि कोई नोड पहले से ही स्कीमा है। पुराने दोषपूर्ण स्कीमा से छुटकारा पाने के लिए mnesia:delete_schema/1 का उपयोग करें।

ध्यान दें कि डिस्क के साथ केवल नोड्स को DiscNodes में शामिल किया DiscNodes । डिस्क-कम नोड्स, यानी नोड्स जहां स्कीमा सहित सभी तालिकाओं में केवल रैम रहता है, को शामिल नहीं किया जाना चाहिए।

create_table (नाम, TabDef) -> {परमाणु, ठीक} | {निरस्त, कारण}

TabDef के तर्क के अनुसार Name नामक एक Mnesia तालिका बनाता है। यह सूची {Item, Value} tuples की सूची होनी चाहिए, जहां निम्नलिखित मानों की अनुमति है:

  • {access_mode, Atom} । एक्सेस मोड डिफ़ॉल्ट रूप से एटम read_write लेकिन इसे एटम read_write पर भी सेट किया जा सकता है। यदि AccessMode को read_only सेट किया read_only , तो टेबल पर अपडेट नहीं किया जा सकता है।

    स्टार्टअप पर, Mnesia हमेशा स्थानीय और अन्य नोड्स पर समाप्त हो जाने पर, भले ही स्थानीय स्तर पर read_only टेबल लोड करता हो। यह तर्क तालिका के एक्सेस मोड को लौटाता है। पहुँच मोड read_only या read_write हो सकता है।

  • {attributes, AtomList} उन अभिलेखों के लिए विशेषता नामों की एक सूची है जो तालिका को आबाद करने वाले हैं। डिफ़ॉल्ट [key, val] । तालिका में कुंजी के अतिरिक्त कम से कम एक अतिरिक्त विशेषता होनी चाहिए।

    किसी रिकॉर्ड में एकल विशेषताओं तक पहुँचने के दौरान, परमाणुओं के रूप में किसी भी विशेषता नाम को हार्ड कोड करने के लिए यह आवश्यक नहीं है, या अनुशंसित भी नहीं है। इसके बजाय निर्माण record_info(fields, RecordName) उपयोग करें। इसका उपयोग RecordName प्रकार के रिकॉर्ड के लिए किया जा सकता है।

  • {disc_copies, Nodelist} , जहां Nodelist नोड्स की एक सूची है, जहां इस तालिका में डिस्क प्रतियां होनी चाहिए। यदि एक तालिका प्रतिकृति प्रकार disc_copies , तो तालिका के इस विशेष प्रतिकृति पर सभी लेखन कार्य डिस्क और तालिका की RAM प्रतिलिपि के लिए लिखे जाते हैं।

    एक नोड पर एक प्रकार की disc_copies और दूसरे नोड पर दूसरे प्रकार की प्रतिकृति तालिका होना संभव है। डिफ़ॉल्ट []

  • {disc_only_copies, Nodelist} , जहां Nodelist नोड्स की एक सूची है, जहां इस तालिका में disc_only_copies । डिस्क पर केवल डिस्क प्रतिकृति रखी गई है और अन्य प्रतिकृति प्रकारों के विपरीत, प्रतिकृति की सामग्री रैम में नहीं रहती है। ये प्रतिकृतियां रैम में आयोजित प्रतिकृतियों की तुलना में काफी धीमी हैं।

  • {index, Intlist} , जहां Intlist विशेषता नामों (परमाणुओं) या रिकॉर्ड फ़ील्ड्स की एक सूची है, जिसके लिए Mnesia एक अतिरिक्त इंडेक्स टेबल का निर्माण और रखरखाव करना है। यदि अनुक्रमणिका उपलब्ध हो तो qlc क्वेरी कंपाइलर प्रश्नों का अनुकूलन करने में सक्षम हो सकता है।

  • {load_order, Integer} । लोड ऑर्डर प्राथमिकता डिफ़ॉल्ट 0 (शून्य) द्वारा होती है, लेकिन इसे किसी भी पूर्णांक पर सेट किया जा सकता है। उच्चतम लोड ऑर्डर प्राथमिकता वाली तालिकाओं को पहले स्टार्टअप पर लोड किया जाता है।

  • {majority, Flag} , जहां Flag बुलियन होना चाहिए। यदि true , तो तालिका में किसी भी (गैर-गंदे) अद्यतन को निरस्त कर दिया जाता है, जब तक कि तालिका के अधिकांश प्रतिरूप समितियों के लिए उपलब्ध न हों। जब एक खंडित टेबल पर उपयोग किया जाता है, तो सभी टुकड़ों को समान बहुमत सेटिंग दी जाती है।

  • {ram_copies, Nodelist} , जहां Nodelist उन नोड्स की एक सूची है जहां इस तालिका में RAM प्रतियां होने की Nodelist है। प्रति लेन-देन के आधार पर डिस्क प्रकार ram_copies की एक तालिका प्रतिकृति नहीं लिखी जाती है। ram_copies प्रतिकृतियां फंक्शन mnesia:dump_tables(Tabs) साथ डिस्क में डंप की जा सकती हैं mnesia:dump_tables(Tabs) । इस विशेषता के लिए डिफ़ॉल्ट मान [node()]

  • {record_name, Name} , जहां Name एक परमाणु होना चाहिए। तालिका में संग्रहीत सभी रिकॉर्ड में यह नाम पहले तत्व के रूप में होना चाहिए। यह टेबल नाम के समान नाम को डिफॉल्ट करता है।

  • {snmp, SnmpStruct} SnmpStruct विवरण के लिए, mnesia:snmp_open_table/2 देखें mnesia:snmp_open_table/2 । यदि यह विशेषता ArgList में ArgList लिए mnesia:create_table/2 , तालिका SNMP द्वारा तुरंत सुलभ है। इसलिए अनुप्रयोग जो सिस्टम को हेरफेर करने और नियंत्रित करने के लिए एसएनएमपी का उपयोग करते हैं, उन्हें आसानी से डिज़ाइन किया जा सकता है, क्योंकि मानेसिया तार्किक तालिकाओं के बीच एक प्रत्यक्ष मानचित्रण प्रदान करता है जो एक एसएनएमपी नियंत्रण अनुप्रयोग और एक मेन्शिया तालिका बनाता है।

  • {storage_properties, [{Backend, Properties}] बैक एंड स्टोरेज के लिए अधिक गुण। Backend वर्तमान में ets या dets हो सकता है। Properties तालिका निर्माण के दौरान बैक एंड स्टोरेज के लिए भेजे गए विकल्पों की एक सूची है। गुणों में पहले से ही उपयोग किए गए गुण शामिल नहीं हो सकते हैं, जैसे कि type या named_table

    उदाहरण के लिए:

    mnesia:create_table(table, [{ram_copies, [node()]}, {disc_only_copies, nodes()},
           {storage_properties,
            [{ets, [compressed]}, {dets, [{auto_save, 5000}]} ]}])
  • {type, Type} , जहाँ Type या तो परमाणुओं के set होना चाहिए, ordered_set , या bag । डिफ़ॉल्ट set । एक set , सभी रिकॉर्ड में अद्वितीय कुंजियाँ होती हैं। एक bag , कई रिकॉर्ड में एक ही कुंजी हो सकती है, लेकिन रिकॉर्ड सामग्री अद्वितीय है। यदि एक गैर-अनूठे रिकॉर्ड को संग्रहीत किया जाता है, तो पुराने परस्पर विरोधी रिकॉर्ड को ओवरराइट किया जाता है।

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

  • {local_content, Bool} , जहां Bool true या false । डिफ़ॉल्ट false

उदाहरण के लिए, निम्न कॉल person तालिका (पहले परिभाषित) बनाता है और इसे दो नोड्स पर दोहराता है:

mnesia:create_table(person,
    [{ram_copies, [N1, N2]},
     {attributes, record_info(fields, person)}]).

यदि यह आवश्यक है कि Mnesia को तालिका में सम्मिलित किए गए सभी person रिकॉर्ड के विशेषता address पर एक अतिरिक्त सूचकांक तालिका का निर्माण और रखरखाव करना चाहिए, तो निम्न कोड जारी किया जाएगा:

mnesia:create_table(person,
    [{ram_copies, [N1, N2]},
     {index, [address]},
     {attributes, record_info(fields, person)}]).

index और attributes विनिर्देशन को क्रमशः {index, [2]} और {attributes, [name, age, address, salary, children]} रूप में कोडित किया जा सकता है।

mnesia:create_table/2 टेबल schema में रिकॉर्ड लिखते हैं। यह फ़ंक्शन, और अन्य सभी स्कीमा हेरफेर फ़ंक्शन, सामान्य लेनदेन प्रबंधन प्रणाली के साथ कार्यान्वित किए जाते हैं। यह गारंटी देता है कि स्कीमा अपडेट परमाणु तरीके से सभी नोड्स पर किए जाते हैं।

निष्क्रिय करें_चेकप्वाइंट (नाम) -> ठीक | {त्रुटि, कारण}

चेकपॉइंट स्वचालित रूप से निष्क्रिय हो जाता है, जब इसमें शामिल कुछ तालिकाओं में कोई अनुचर नहीं होता है। यह तब हो सकता है जब नोड्स नीचे जाते हैं या जब एक प्रतिकृति हटा दी जाती है। इस फ़ंक्शन के साथ चेकपॉइंट भी निष्क्रिय कर दिए गए हैं। Name एक सक्रिय चौकी का Name है।

del_table_copy (टैब, नोड) -> {निरस्त, R} | {परमाणु, ठीक है}

नोड Node पर तालिका Tab की प्रतिकृति को हटाता है। जब अंतिम प्रतिकृति को इस फ़ंक्शन के साथ हटा दिया जाता है, तो तालिका पूरी तरह से गायब हो जाती है।

इस फ़ंक्शन का उपयोग schema नामक तालिका की प्रतिकृति को हटाने के लिए भी किया जा सकता है। Mnesia नोड को तब हटा दिया जाता है। ध्यान दें कि Mnesia को पहले नोड पर रोका जाना चाहिए।

del_table_index (टैब, AttrName) -> {निरस्त, R} | {परमाणु, ठीक है}

तालिका में AttrName नाम के साथ विशेषता पर सूचकांक हटाता है।

हटाएँ ({टैब, कुंजी}) -> लेन-देन गर्भपात | ठीक

mnesia:delete(Tab, Key, write) कॉल mnesia:delete(Tab, Key, write)

delete (टैब, की, लॉककिंड) -> ट्रांजेक्शन एबॉर्ट | ठीक

कुंजी के साथ तालिका Tab में सभी रिकॉर्ड हटाता है।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। विवरण के लिए, mnesia:activity/4 देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह रिकॉर्ड में लॉक लॉक ऑफ़ टाइप टाइप का अधिग्रहण करता है। वर्तमान में, लॉक प्रकार write और sticky_write समर्थित हैं।

delete_object (रिकॉर्ड) -> लेनदेन गर्भपात | ठीक

mnesia:delete_object(Tab, Record, write) कॉल mnesia:delete_object(Tab, Record, write) , जहां Tab element(1, Record)

delete_object (टैब, रिकॉर्ड, लॉककिंड) -> लेन-देन गर्भपात | ठीक

यदि एक टेबल प्रकार का bag , तो कभी-कभी एक निश्चित कुंजी के साथ केवल कुछ रिकॉर्ड को हटाने की आवश्यकता हो सकती है। यह फ़ंक्शन delete_object/3 साथ किया जा सकता है। इस फ़ंक्शन के लिए एक पूर्ण रिकॉर्ड प्रदान किया जाना चाहिए।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। विवरण के लिए, mnesia:activity/4 देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह रिकॉर्ड पर लॉक लॉक ऑफ़ टाइप टाइप का अधिग्रहण करता है। वर्तमान में, लॉक प्रकार write और sticky_write समर्थित हैं।

delete_schema (DiscNodes) -> ठीक | {त्रुटि, कारण}

एक डेटाबेस mnesia:create_schema/1 के साथ बनाया गया है mnesia:create_schema/1 mnesia:delete_schema/1 विफल हो जाता है यदि कोई भी DiscNodes नोड दिया जाता है जैसे कि DiscNodes जीवित नहीं हैं, या यदि मेन्सिया किसी भी नोड पर चल रहा है।

डेटाबेस हटाए जाने के बाद, डिस्क-कम नोड के रूप में Mnesia शुरू करना अभी भी संभव हो सकता है। यह इस बात पर निर्भर करता है कि schema_location पैरामीटर schema_location कैसे सेट है

चेतावनी

इस फ़ंक्शन का उपयोग अत्यधिक सावधानी के साथ करें, क्योंकि यह मौजूदा स्थायी डेटा को अप्रचलित बनाता है। इसे इस्तेमाल करने से पहले दो बार सोचें।

delete_table (टैब) -> {निरस्त, कारण} | {परमाणु, ठीक है}

तालिका Tab सभी प्रतिकृतियों को स्थायी रूप से हटा देता है।

गंदे_आल_कीज़ (टैब) -> कीलिस्ट | बाहर निकलें ({निरस्त, कारण})

फंक्शन mnesia:all_keys/1 गंदे बराबर mnesia:all_keys/1

गंदा_डेलीट ({टैब, की}) -> ठीक | बाहर निकलें ({निरस्त, कारण})

mnesia:dirty_delete(Tab, Key) कॉल mnesia:dirty_delete(Tab, Key)

गंदा_डेलीट (टैब, की) -> ठीक | बाहर निकलें ({निरस्त, कारण})

फंक्शन mnesia:delete/3 डर्टी बराबर mnesia:delete/3

dirty_delete_object (रिकार्ड)

mnesia:dirty_delete_object(Tab, Record) , जहां Tab element(1, Record)

गंदा_डेली_बॉजेक्ट (टैब, रिकॉर्ड)

फंक्शन mnesia:delete_object/3 का डर्टी समतुल्य mnesia:delete_object/3

गंदा_फर्स्ट (टैब) -> कुंजी | बाहर निकलें ({निरस्त, कारण})

set या bag टेबल में रिकॉर्ड का आदेश नहीं दिया जाता है। हालांकि, रिकॉर्ड का एक आदेश है जो उपयोगकर्ता के लिए अज्ञात है। इसलिए, इस तालिका को फ़ंक्शन mnesia:dirty_next/2 साथ इस कार्य द्वारा पता लगाया जा सकता है mnesia:dirty_next/2

यदि तालिका में कोई रिकॉर्ड नहीं हैं, तो यह फ़ंक्शन परमाणु को '$end_of_table' । इसलिए यह अत्यधिक अवांछनीय है, लेकिन अस्वीकृत नहीं है, इस परमाणु को किसी भी उपयोगकर्ता रिकॉर्ड के लिए कुंजी के रूप में उपयोग करने के लिए।

गंदा_इंडेक्स_मैच_बॉजेक्ट (पैटर्न, स्थिति)

mnesia:dirty_index_match_object(Tab, Pattern, Pos) शुरू होता है mnesia:dirty_index_match_object(Tab, Pattern, Pos) , जहां Tab element(1, Pattern)

गंदा_इंडेक्स_मैच_बजेक्ट (टैब, पैटर्न, स्थिति)

फंक्शन mnesia:index_match_object/4 का डर्टी समकक्ष mnesia:index_match_object/4

गंदा_इंडेक्स_्रेड (टैब, सेकेंडरीके, पॉस)

फंक्शन mnesia:index_read/3 का डर्टी समकक्ष mnesia:index_read/3

गंदा_लॉस्ट (टैब) -> कुंजी | बाहर निकलें ({निरस्त, कारण})

बिल्कुल mnesia:dirty_first/1 तरह काम करता है mnesia:dirty_first/1 लेकिन ऑर्डर किए गए तालिका प्रकार के लिए ordered_set शब्द क्रम में अंतिम वस्तु देता है। अन्य सभी प्रकार की mnesia:dirty_first/1 , mnesia:dirty_first/1 और mnesia:dirty_last/1 पर्यायवाची शब्द हैं।

गंदे_मंच_बजेक्ट (प्रतिमान) -> रिकॉर्डलिस्ट | बाहर निकलें ({निरस्त, कारण})

mnesia:dirty_match_object(Tab, Pattern) , जहां Tab element(1, Pattern)

गंदा_मंच_बॉज (टैब, पैटर्न) -> रिकार्डलिस्ट | बाहर निकलें ({निरस्त, कारण})

फंक्शन mnesia:match_object/3 डर्टी समकक्ष mnesia:match_object/3

गंदा_नेक्स्ट (टैब, की) -> कुंजी | बाहर निकलें ({निरस्त, कारण})

एक तालिका का पता लगाता है और तालिका में सभी रिकॉर्ड पर संचालन करता है। जब तालिका का अंत पहुँच जाता है, तो विशेष कुंजी '$end_of_table' वापस आ जाती है। अन्यथा, फ़ंक्शन एक कुंजी देता है जिसका उपयोग वास्तविक रिकॉर्ड पढ़ने के लिए किया जा सकता है। यदि कोई अन्य Erlang प्रक्रिया कार्य तालिका पर लेखन कार्य निष्पादित करती है, तो यह अपरिभाषित है, क्योंकि यह फ़ंक्शन mnesia:dirty_next/2 साथ ट्रेस किया जा रहा है mnesia:dirty_next/2

गंदा_पर्व (टैब, कुंजी) -> कुंजी | बाहर निकलें ({निरस्त, कारण})

बिल्कुल mnesia:dirty_next/2 तरह काम करता है mnesia:dirty_next/2 लेकिन ऑर्डर की ordered_set तालिका प्रकार के लिए ordered_set शब्द क्रम में पिछली वस्तु को ordered_set । अन्य सभी प्रकार की mnesia:dirty_next/2 , mnesia:dirty_next/2 और mnesia:dirty_prev/2 पर्यायवाची हैं।

मैला_क्रेड ({टैब, की}) -> वैल्यूलिस्ट | बाहर निकलें ({निरस्त, कारण}

mnesia:dirty_read(Tab, Key) कॉल mnesia:dirty_read(Tab, Key)

मैला_क्रेड (टैब, की) -> वैल्यूलिस्ट | बाहर निकलें ({निरस्त, कारण}

फ़ंक्शन mnesia:read/3 गंदे बराबर mnesia:read/3

गंदा_सेले (टैब, माचिस) -> वैल्यूलिस्ट | बाहर निकलें ({निरस्त, कारण}

फंक्शन mnesia:select/2 डर्टी समकक्ष mnesia:select/2

गंदा_लॉट (टैब, स्लॉट) -> रिकार्डलिस्ट | बाहर निकलें ({निरस्त, कारण})

फ़ंक्शन mnesia:dirty_next/2 समान तरीके से एक तालिका को mnesia:dirty_next/2 । एक टेबल में कई स्लॉट होते हैं जो 0 (शून्य) से लेकर अज्ञात ऊपरी सीमा तक होते हैं। फ़ंक्शन mnesia:dirty_slot/2 तालिका के अंत तक पहुंचने पर विशेष परमाणु '$end_of_table' है। इस फ़ंक्शन का व्यवहार अपरिभाषित है अगर एक लिखित ऑपरेशन टेबल पर किया जाता है जबकि यह ट्रैवर्स किया जा रहा है।

गंदा_अपडेट_काउंटर ({टैब, की}, Incr) -> NewVal | बाहर निकलें ({निरस्त, कारण})

mnesia:dirty_update_counter(Tab, Key, Incr) कॉल mnesia:dirty_update_counter(Tab, Key, Incr)

गंदा_अपडेट_काउंटर (टैब, की, इंक्र) -> NewVal | बाहर निकलें ({निरस्त, कारण})

मानेसिया के पास कोई विशेष काउंटर रिकॉर्ड नहीं है। हालांकि, {Tab, Key, Integer} होने पर फॉर्म {Tab, Key, Integer} फॉर्म के रिकॉर्ड (संभवतः डिस्क-निवासी) काउंटर के रूप में उपयोग किए जा सकते हैं। यह फ़ंक्शन एक सकारात्मक या नकारात्मक संख्या के साथ एक काउंटर को अपडेट करता है। हालांकि, काउंटर कभी भी शून्य से कम नहीं बन सकते हैं। इस फ़ंक्शन और रिकॉर्ड को पढ़ने, पहले अंकगणित का प्रदर्शन करने और फिर रिकॉर्ड लिखने की क्रिया के बीच दो महत्वपूर्ण अंतर हैं:

  • यह बहुत अधिक कुशल है।
  • mnesia:dirty_update_counter/3 को एक परमाणु ऑपरेशन के रूप में किया जाता है, हालांकि यह एक लेनदेन द्वारा संरक्षित नहीं है।

यदि दो प्रक्रियाएं mnesia:dirty_update_counter/3 एक साथ mnesia:dirty_update_counter/3 अपडेट, दोनों अपडेट में से किसी एक को खोने के जोखिम के बिना प्रभावी होते हैं। काउंटर का नया मान NewVal लौटाया गया है।

यदि Key मौजूद नहीं है, तो मान के साथ एक नया रिकॉर्ड बनाया जाता है यदि यह 0 से बड़ा है, अन्यथा यह 0 पर सेट है।

गंदा_लेख (रिकॉर्ड) -> ठीक | बाहर निकलें ({निरस्त, कारण})

mnesia:dirty_write(Tab, Record) , जहां Tab element(1, Record)

गंदा_लेख (टैब, रिकॉर्ड) -> ठीक | बाहर निकलें ({निरस्त, कारण})

फ़ंक्शन mnesia:write/3 गंदे बराबर mnesia:write/3

डंप_लॉग () -> डंप

स्थानीय लॉग फ़ाइल का उपयोगकर्ता-आरंभित डंप करता है। यह आमतौर पर आवश्यक नहीं है, क्योंकि Mnesia डिफ़ॉल्ट रूप से यह स्वचालित रूप से प्रबंधित करता है। कॉन्फ़िगरेशन पैरामीटर dump_log_time_threshold और dump_log_write_threshold देखें।

डंप_टैबल्स (टैबलिस्ट) -> {परमाणु, ठीक} | {निरस्त, कारण}

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

dump_to_textfile (फ़ाइल का नाम)

एक Mnesia प्रणाली की सभी स्थानीय तालिकाओं को एक पाठ फ़ाइल में डंप करता है, जिसे संपादित किया जा सकता है (एक सामान्य पाठ संपादक द्वारा) और फिर mnesia:load_textfile/1 साथ पुनः लोड किया जा सकता है mnesia:load_textfile/1 । केवल शैक्षिक उद्देश्यों के लिए इस फ़ंक्शन का उपयोग करें। वास्तविक बैकअप से निपटने के लिए अन्य कार्यों का उपयोग करें।

error_description (त्रुटि) -> स्ट्रिंग

सभी Mnesia लेनदेन, जिसमें सभी स्कीमा अपडेट फ़ंक्शन शामिल हैं, या तो {atomic, Val} या tuple {aborted, Reason} मान लौटाते हैं। Reason निम्न सूची में परमाणुओं में से कोई भी हो सकता है। फ़ंक्शन error_description/1 एक वर्णनात्मक स्ट्रिंग देता है जो त्रुटि का वर्णन करता है।

  • nested_transaction । इस संदर्भ में नेस्टेड लेनदेन की अनुमति नहीं है।
  • badarg । खराब या अमान्य तर्क, संभवतः खराब प्रकार।
  • no_transaction । ऑपरेशन से बाहर लेनदेन की अनुमति नहीं है।
  • combine_error । टेबल विकल्प अवैध रूप से संयुक्त।
  • bad_index । सूचकांक पहले से मौजूद है, या सीमा से बाहर था।
  • already_exists । सक्रिय होने का स्कीमा विकल्प पहले से ही चालू है।
  • index_exists । कुछ संचालन को एक सूचकांक के साथ तालिकाओं पर नहीं किया जा सकता है।
  • no_exists । गैर-मौजूदा (नहीं-जीवित) आइटम पर ऑपरेशन करने की कोशिश की।
  • system_limit । एक सिस्टम सीमा समाप्त हो गई थी।
  • mnesia_down । लेन-देन में दूरस्थ नोड पर रिकॉर्ड शामिल होते हैं, जो लेनदेन पूरा होने से पहले अनुपलब्ध हो जाता है। रिकॉर्ड अब नेटवर्क में कहीं और उपलब्ध नहीं हैं।
  • not_a_db_node । एक नोड का उल्लेख किया गया था जो स्कीमा में मौजूद नहीं है।
  • bad_type । वाद में निर्दिष्ट बुरा प्रकार।
  • node_not_running । नोड नहीं चल रहा है।
  • truncated_binary_file । फ़ाइल में काटे गए बाइनरी।
  • active । कुछ डिलीट ऑपरेशंस के लिए आवश्यक है कि सभी सक्रिय रिकॉर्ड हटा दिए जाएं।
  • illegal । ऑपरेशन इस रिकॉर्ड पर समर्थित नहीं है।

Error हो सकता है Reason , {error, Reason} या {aborted, Reason} । पहले क्षेत्र में एक परमाणु के रूप में Reason एक परमाणु या ट्यूपल हो सकता है Reason

निम्नलिखित उदाहरण एक फ़ंक्शन का वर्णन करते हैं जो एक त्रुटि देता है, और अधिक विस्तृत त्रुटि जानकारी प्राप्त करने की विधि:

  • फ़ंक्शन mnesia:create_table(bar, [{attributes, 3.14}]) टपल लौटाता है {aborted,Reason} , जहां Reason टपल है {bad_type,bar,3.14000}
  • फ़ंक्शन mnesia:error_description(Reason) शब्द लौटाता है {"Bad type on some provided arguments",bar,3.14000} , जो प्रदर्शन के लिए उपयुक्त एक त्रुटि विवरण है।
ets (मज़ा, [, Args]) -> ResultOfFun | बाहर निकलने के (कारण)

Fun एक कच्चे संदर्भ में कॉल करता है जो लेनदेन द्वारा संरक्षित नहीं है। Mnesia फ़ंक्शन कॉल Fun में स्थानीय ईटीएस तालिकाओं पर सीधे प्रदर्शन किया जाता है और इस धारणा पर प्रदर्शन किया जाता है कि स्थानीय भंडारण प्रकार है ram_copies और तालिकाओं को अन्य नोड्स में दोहराया नहीं जाता है। सदस्यता को ट्रिगर नहीं किया जाता है और चौकियों को अपडेट नहीं किया जाता है, लेकिन यह बहुत तेज़ है। यह फ़ंक्शन disc_copies तालिकाओं पर भी लागू किया जा सकता है यदि सभी ऑपरेशन केवल पढ़े जाते हैं। विवरण के लिए, देखें mnesia:activity/4 और उपयोगकर्ता की मार्गदर्शिका।

ध्यान दें कि mnesia:ets लेनदेन-संदर्भ के अंदर कॉलिंग (घोंसला बनाना) लेनदेन शब्दार्थ को विरासत में मिला है।

पहला (टैब) -> कुंजी | लेन-देन गर्भपात

set या bag तालिकाओं में रिकॉर्ड का आदेश नहीं दिया जाता है। हालांकि, रिकॉर्ड का एक आदेश है जो उपयोगकर्ता के लिए अज्ञात है। इसलिए इस फ़ंक्शन के साथ एक तालिका का पता लगाया जा सकता है mnesia:next/2

यदि तालिका में कोई रिकॉर्ड नहीं हैं, तो यह फ़ंक्शन परमाणु को वापस करता है '$end_of_table' । इसलिए यह अत्यधिक अवांछनीय है, लेकिन अस्वीकृत नहीं, किसी भी उपयोगकर्ता रिकॉर्ड के लिए इस परमाणु का उपयोग करना।

तह (कार्य, Acc, तालिका) -> NewAcc | लेन-देन गर्भपात

तालिका के ऊपर Iterates Table और तालिका में Function(Record, NewAcc) प्रत्येक के लिए कॉल Record करता है। से लौटाए गए शब्द Function का उपयोग अगली कॉल में दूसरे तर्क के रूप में किया जाता है Function

foldl वही शब्द लौटाता है जो अंतिम कॉल के रूप में Function लौटा है।

तह (कार्य, Acc, तालिका) -> NewAcc | लेन-देन गर्भपात

बिल्कुल काम करता है, foldl/3 लेकिन ordered_set तालिका प्रकार के लिए विपरीत क्रम में तालिका को पुनरावृत्त करता है । अन्य सभी प्रकार की तालिका के लिए, foldr/3 और foldl/3 समानार्थक शब्द हैं।

force_load_table (टैब) -> हाँ | त्रुटि विवरण

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

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

index_match_object (पैटर्न, स्थिति) -> लेनदेन गर्भपात | ObjList

शुरू होता है mnesia:index_match_object(Tab, Pattern, Pos, read) , जहां Tab है element(1, Pattern)

index_match_object (टैब, पैटर्न, स्थिति, लॉककींड) -> लेनदेन गर्भपात | ObjList

फ़ंक्शन के समान तरीके से mnesia:index_read/3 , किसी भी अनुक्रमणिका जानकारी का उपयोग रिकॉर्ड्स से मिलान करने के लिए किया जा सकता है। यह फ़ंक्शन एक पैटर्न लेता है जो फ़ंक्शन के समान नियमों का पालन करता है mnesia:match_object/3 , सिवाय इसके कि इस फ़ंक्शन को निम्न स्थितियों की आवश्यकता होती है:

  • तालिका में Tab स्थिति पर एक सूचकांक होना चाहिए Pos

  • स्थिति Pos में तत्व Pattern बाध्य होना चाहिए। Pos एक पूर्णांक ( #record.Field ) या एक विशेषता नाम है।

यहाँ वर्णित दो अनुक्रमणिका खोज फ़ंक्शंस स्वचालित रूप से तब शुरू होते हैं जब qlc सूची बोध के साथ तालिकाओं की खोज की जाती है और निम्न-स्तरीय mnesia:[dirty_]match_object फ़ंक्शंस का उपयोग करते समय भी ।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह LockKind संपूर्ण तालिका या किसी एकल रिकॉर्ड पर एक प्रकार का लॉक प्राप्त करता है । वर्तमान में, लॉक प्रकार read समर्थित है।

index_read (टैब, सेकेंडरीके, स्थिति) -> लेन-देन गर्भपात | RecordList

मान लें कि Pos एक निश्चित रिकॉर्ड प्रकार के लिए स्थिति पर एक सूचकांक है । इस फ़ंक्शन का उपयोग रिकॉर्ड के लिए वास्तविक कुंजी को जाने बिना रिकॉर्ड को पढ़ने के लिए किया जा सकता है। उदाहरण के लिए, तालिका 1 की स्थिति के सूचकांक के साथ person , कॉल mnesia:index_read(person, 36, #person.age) 36 वर्ष की आयु के सभी व्यक्तियों की एक सूची देता है। Pos यह एक विशेषता नाम (परमाणु) भी हो सकता है, लेकिन यदि संकेतन mnesia:index_read(person, 36, age) का उपयोग किया जाता है, तो क्षेत्र स्थिति रनटाइम में खोजी जाती है, प्रत्येक कॉल के लिए।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह पूरी तालिका पर एक रीड लॉक प्राप्त करता है।

जानकारी () -> ठीक है

टर्मिनल पर प्रिंट सिस्टम की जानकारी। इस फ़ंक्शन का उपयोग तब भी किया जा सकता है, जब मानेसिया शुरू न हो। हालांकि, अधिक जानकारी प्रदर्शित की जाती है यदि मानेसिया शुरू किया जाता है।

install_fallback (अपारदर्शी) -> ठीक | {त्रुटि, कारण}

कहता है mnesia:install_fallback(Opaque, Args) , जहां Args है [{scope, global}]

install_fallback (अपारदर्शी), BackupMod) -> ठीक | {त्रुटि, कारण}

कहता है mnesia:install_fallback(Opaque, Args) , जहां Args है [{scope, global}, {module, BackupMod}]

install_fallback (अपारदर्शी, आर्ग्स) -> ठीक | {त्रुटि, कारण}

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

Args निम्नलिखित ट्यूपल्स की एक सूची है:

  • {module, BackupMod} । बैकअप मीडिया के सभी एक्सेस का नाम कॉलबैक मॉड्यूल के माध्यम से किया जाता है BackupMod । तर्क Opaque कॉलबैक मॉड्यूल को अग्रेषित किया जाता है, जो इसे अपनी इच्छानुसार व्याख्या कर सकता है। डिफ़ॉल्ट कॉलबैक मॉड्यूल कहा जाता है mnesia_backup और यह Opaque स्थानीय फ़ाइल नाम के रूप में तर्क की व्याख्या करता है। इस मॉड्यूल के लिए डिफ़ॉल्ट भी कॉन्फ़िगरेशन पैरामीटर के माध्यम से कॉन्फ़िगर करने योग्य है -mnesia mnesia_backup

  • {scope, Scope} Scope एक वापस आने के दोनों है global पूरे डेटाबेस के लिए या local एक नोड के लिए। डिफ़ॉल्ट रूप से, फ़ॉलबैक की स्थापना एक वैश्विक ऑपरेशन है, जो या तो डिस्क-निवासी स्कीमा के साथ सभी नोड्स पर किया जाता है या कोई नहीं। जो नोड डिस्क-निवासी हैं वे बैकअप में स्कीमा जानकारी से निर्धारित होते हैं।

    यदि Scope ऑपरेशन है local , तो फॉलबैक केवल स्थानीय नोड पर स्थापित किया गया है।

  • {mnesia_dir, AlternateDir} । यह तर्क केवल मान्य है यदि संस्थापन का दायरा है local । आम तौर पर एक कमबैक की स्थापना को Mnesia निर्देशिका को लक्षित किया जाता है, जैसा कि कॉन्फ़िगरेशन पैरामीटर के साथ कॉन्फ़िगर किया गया है -mnesia dir । लेकिन स्पष्ट रूप से एक की आपूर्ति करके AlternateDir , फॉलबैक को Mnesia निर्देशिका कॉन्फ़िगरेशन पैरामीटर सेटिंग की परवाह किए बिना वहां स्थापित किया गया है। एक वैकल्पिक Mnesia निर्देशिका पर कमबैक की स्थापना के बाद, वह निर्देशिका सक्रिय Mnesia निर्देशिका के रूप में उपयोग के लिए पूरी तरह से तैयार है।

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

is_transaction () -> बूलियन

जब इस फ़ंक्शन को लेनदेन-संदर्भ के अंदर निष्पादित किया जाता है, तो यह वापस आ जाता है true , अन्यथा false

अंतिम (टैब) -> कुंजी | लेन-देन गर्भपात

बिलकुल पसंद करता है mnesia:first/1 , लेकिन ordered_set तालिका प्रकार के लिए Erlang शब्द क्रम में अंतिम वस्तु देता है । अन्य सभी प्रकार की तालिका के लिए, mnesia:first/1 और mnesia:last/1 समानार्थक शब्द हैं।

load_textfile (फ़ाइल का नाम)

mnesia:dump_to_textfile/1 Mnesia में पाठ फ़ाइल (जनरेट ) के साथ परिभाषाओं और डेटा की एक श्रृंखला को लोड करता है । यह फ़ंक्शन Mnesia भी शुरू करता है और संभवतः एक नया स्कीमा बनाता है। यह समारोह केवल शैक्षिक उद्देश्यों के लिए है। वास्तविक बैकअप से निपटने के लिए अन्य कार्यों का उपयोग करने की सिफारिश की जाती है।

लॉक (LockItem, LockKind) -> नोड्स | ठीक है | लेन-देन गर्भपात

लिखें ताले आम तौर पर सभी नोड्स पर प्राप्त किए जाते हैं जहां तालिका की एक प्रतिकृति रहती है (और सक्रिय है)। पढ़ें एक नोड पर ताले प्राप्त किए जाते हैं (यदि स्थानीय प्रतिकृति मौजूद है तो स्थानीय नोड)। यदि वे लेन-देन-संदर्भ में शुरू किए जाते हैं, तो अधिकांश संदर्भ-संवेदनशील पहुंच फ़ंक्शन एक अंतर्निहित लॉक प्राप्त करते हैं। एक लॉक की ग्रैन्युलैरिटी या तो एक एकल रिकॉर्ड या संपूर्ण तालिका हो सकती है।

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

फ़ंक्शन mnesia:lock/2 का उद्देश्य तालिकाओं पर स्पष्ट लॉकिंग का समर्थन करना है, लेकिन उन स्थितियों के लिए भी है, जब तालिकाओं को दोहराया जाता है, भले ही ताले को अधिग्रहित करने की आवश्यकता हो। वर्तमान में, दो प्रकार LockKind समर्थित हैं:

write

लिखें ताले अनन्य हैं। इसका मतलब यह है कि यदि कोई लेन-देन किसी आइटम पर राइट लॉक हासिल करने का प्रबंधन करता है, तो कोई भी अन्य लेन-देन उसी आइटम पर किसी भी तरह का लॉक हासिल नहीं कर सकता।

read

पढ़ें ताले साझा किए जा सकते हैं। इसका मतलब यह है कि यदि कोई लेनदेन किसी आइटम पर रीड लॉक प्राप्त करने का प्रबंधन करता है, तो अन्य लेनदेन भी उसी आइटम पर रीड लॉक प्राप्त कर सकते हैं। हालांकि, अगर किसी के पास रीड लॉक है, तो कोई भी उसी आइटम पर राइट लॉक हासिल नहीं कर सकता है। यदि किसी के पास राइट लॉक है, तो कोई भी रीड लॉक या एक ही आइटम पर राइट लॉक हासिल नहीं कर सकता है।

गतिरोध लॉक अनुरोध स्वचालित रूप से पंक्तिबद्ध होते हैं यदि कोई गतिरोध का कोई जोखिम नहीं है। अन्यथा लेनदेन को समाप्त कर दिया जाना चाहिए। Mnesia स्वचालित रूप से तब तक करता है जब तक कि अधिकतम की ऊपरी सीमा retries नहीं पहुंच जाती है। जानकारी के लिए, देखें mnesia:transaction/3

पूर्णता की खातिर, स्टिकी राइट लॉक को यहां भी वर्णित किया जाता है, भले ही स्टिकी राइट लॉक इस फ़ंक्शन द्वारा समर्थित न हो:

sticky_write

स्टिकी राइट लॉक एक ऐसा तंत्र है जिसका उपयोग राइट लॉक अधिग्रहण को अनुकूलित करने के लिए किया जा सकता है। यदि आपका आवेदन मुख्य रूप से गलती सहिष्णुता के लिए प्रतिकृति तालिकाओं का उपयोग करता है (जैसा कि पहुंच अनुकूलन उद्देश्य को पढ़ने के लिए विरोध किया जाता है), तो चिपचिपा ताले सबसे अच्छा विकल्प उपलब्ध हो सकते हैं।

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

वर्तमान में, यह फ़ंक्शन दो प्रकारों का समर्थन करता है LockItem :

{table, Tab}

यह LockKind संपूर्ण तालिका पर एक प्रकार का लॉक प्राप्त करता है Tab

{global, GlobalKey, Nodes}

यह LockKind वैश्विक संसाधन पर एक प्रकार का लॉक प्राप्त करता है GlobalKey Nodes सूची में सभी सक्रिय नोड्स पर लॉक का अधिग्रहण किया गया है ।

सबसे बाहरी लेन-देन समाप्त होने पर ताले छोड़ दिए जाते हैं।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह ताले प्राप्त करता है, अन्यथा यह अनुरोध को अनदेखा करता है।

match_object (पैटर्न) -> लेनदेन गर्भपात | RecList

कहता है mnesia:match_object(Tab, Pattern, read) , जहां Tab है element(1, Pattern)

match_object (टैब, पैटर्न, लॉककिंड) -> लेन-देन गर्भपात | RecList

एक '_' पैरामीटर के रूप में निरूपित "परवाह न करें" चर के साथ एक पैटर्न लेता है । यह फ़ंक्शन पैटर्न से मेल खाने वाले रिकॉर्ड की एक सूची देता है। चूंकि किसी तालिका में रिकॉर्ड के दूसरे तत्व को रिकॉर्ड के लिए महत्वपूर्ण माना जाता है, इसलिए इस फ़ंक्शन का प्रदर्शन इस बात पर निर्भर करता है कि यह कुंजी बाध्य है या नहीं।

उदाहरण के लिए, कॉल 36 के क्षेत्र के mnesia:match_object(person, {person, '_', 36, '_', '_'}, read) साथ सभी व्यक्ति रिकॉर्ड की एक सूची देता है age

mnesia:match_object/3 यदि ये मौजूद हैं तो फ़ंक्शन स्वचालित रूप से अनुक्रमित का उपयोग करता है। हालांकि, सर्वश्रेष्ठ सूचकांक का चयन करने के लिए कोई अनुमान नहीं लगाया जाता है।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह LockKind संपूर्ण तालिका या एकल रिकॉर्ड पर एक प्रकार का लॉक प्राप्त करता है । वर्तमान में, लॉक प्रकार read समर्थित है।

Move_table_copy (टैब, से, तक) -> {निरस्त, कारण} | {परमाणु, ठीक है}

Tab नोड से नोड में तालिका की प्रतिलिपि ले From जाता है To

भंडारण प्रकार संरक्षित है। उदाहरण के लिए, एक नोड से स्थानांतरित की गई RAM तालिका नए नोड पर एक RAM बनी हुई है। अन्य लेन-देन अभी भी तालिका में पढ़ और लिख सकते हैं जबकि इसे स्थानांतरित किया जा रहा है।

इस फ़ंक्शन का उपयोग local_content तालिकाओं पर नहीं किया जा सकता है ।

अगला (टैब, कुंजी) -> कुंजी | लेन-देन गर्भपात

एक तालिका का पता लगाता है और तालिका में सभी रिकॉर्ड पर संचालन करता है। जब तालिका का अंत पहुँच जाता है, तो विशेष कुंजी '$end_of_table' वापस आ जाती है। अन्यथा फ़ंक्शन एक कुंजी देता है जिसका उपयोग वास्तविक रिकॉर्ड पढ़ने के लिए किया जा सकता है।

prev (टैब, की) -> कुंजी | लेन-देन गर्भपात

बिलकुल पसंद करता है mnesia:next/2 , लेकिन ordered_set तालिका प्रकार के लिए Erlang शब्द क्रम में पिछली वस्तु को वापस करता है । अन्य सभी प्रकार की तालिका के लिए, mnesia:next/2 और mnesia:prev/2 समानार्थक शब्द हैं।

read ({टैब, की}) -> ट्रांजैक्शन एबॉर्ट | RecordList

फ़ंक्शन को कॉल करता है mnesia:read(Tab, Key, read)

read (टैब, की) -> ट्रांजैक्शन एबॉर्ट | RecordList

फ़ंक्शन को कॉल करता है mnesia:read(Tab, Key, read)

read (टैब, की, लॉककिंड) -> ट्रांजैक्शन एबॉर्ट | RecordList

Tab कुंजी के साथ तालिका से सभी रिकॉर्ड पढ़ता है Key । इस फ़ंक्शन के स्थान की परवाह किए बिना एक ही शब्दार्थ है Tab । यदि तालिका प्रकार की है bag , तो फ़ंक्शन mnesia:read(Tab, Key) मनमाने ढंग से लंबी सूची वापस कर सकता है। यदि तालिका प्रकार की है set , तो सूची 1 लंबाई की है, या []

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह एक प्रकार का लॉक प्राप्त करता है LockKind । वर्तमान में, ताला प्रकार read , write और sticky_write समर्थित हैं।

उपयोगकर्ता रिकॉर्ड को अपडेट करना चाहता है, इसे और अधिक उपयोग करने के लिए सक्षम है write/sticky_write के रूप में LockKind । यदि मेज पर बहुमत की जाँच सक्रिय है, तो जैसे ही राइट लॉक का प्रयास किया जाता है, जाँच की जाती है। इसका उपयोग जल्दी से समाप्त करने के लिए किया जा सकता है यदि बहुमत की स्थिति पूरी नहीं हुई है।

read_lock_table (टैब) -> ठीक है | लेन-देन गर्भपात

फ़ंक्शन को कॉल करता है mnesia:lock({table, Tab}, read)

report_event (घटना) -> ठीक है

जब Mnesia अनुप्रयोगों की एक प्रणाली को ट्रेस किया जाता है, तो यह अनुप्रयोग से संबंधित घटनाओं के साथ Mnesia के स्वयं के ईवेंट को इंटरलेवे करने में सक्षम होता है जो एप्लिकेशन संदर्भ के बारे में जानकारी देता है।

जब भी एप्लिकेशन एक नया और मांगलिक कार्य शुरू करता है, या यदि यह अपने निष्पादन में एक नया दिलचस्प चरण डालता है, तो इसका उपयोग करना एक अच्छा विचार हो सकता है mnesia:report_event/1 Event कोई भी शब्द हो सकता है और {mnesia_user, Event} किसी भी प्रक्रिया के लिए एक घटना उत्पन्न करता है जो Mnesia सिस्टम ईवेंट की सदस्यता लेता है।

पुनर्स्थापना (अपारदर्शी, आर्ग्स) -> {परमाणु, पुनर्स्थापनटैब} | {निरस्त, कारण}

इस फ़ंक्शन के साथ, टेबल को मानेसिया को पुनरारंभ किए बिना बैकअप से ऑनलाइन बहाल किया जा सकता है। Opaque बैकअप मॉड्यूल के लिए भेजा जाता है। Args निम्नलिखित ट्यूपल्स की एक सूची है:

  • {module,BackupMod} BackupMod बैकअप मीडिया का उपयोग करने के लिए बैकअप मॉड्यूल का उपयोग किया जाता है। यदि छोड़ा गया है, तो डिफ़ॉल्ट बैकअप मॉड्यूल का उपयोग किया जाता है।
  • {skip_tables, TabList} , जहां TabList तालिकाओं की एक सूची है जिसे बैकअप से पढ़ा नहीं जाना है।
  • {clear_tables, TabList} , जहां TabList एक सूची है जो बैकअप से रिकॉर्ड डालने से पहले साफ़ की जानी है। यही है, तालिकाओं को पुनर्स्थापित करने से पहले तालिकाओं में सभी रिकॉर्ड हटा दिए जाते हैं। तालिकाओं के बारे में स्कीमा जानकारी बैकअप से साफ़ या पढ़ी नहीं गई है।
  • {keep_tables, TabList} , जहां TabList एक सूची है जो बैकअप से रिकॉर्ड सम्मिलित होने से पहले साफ़ नहीं की जानी है। यही है, बैकअप में रिकॉर्ड तालिका में रिकॉर्ड में जोड़े जाते हैं। तालिकाओं के बारे में स्कीमा जानकारी बैकअप से साफ़ या पढ़ी नहीं गई है।
  • {recreate_tables, TabList} , जहां TabList एक सूची है जो बैकअप से रिकॉर्ड डालने से पहले फिर से बनाया जाना है। तालिकाओं को पहले हटा दिया जाता है और फिर बैकअप से स्कीमा जानकारी के साथ बनाया जाता है। बैकअप में सभी नोड्स को चालू करने की आवश्यकता है।
  • {default_op, Operation} , जहां Operation आपरेशन के या तो है skip_tables , clear_tables , keep_tables , या recreate_tables । डिफ़ॉल्ट ऑपरेशन निर्दिष्ट करता है कि कौन सा ऑपरेशन बैकअप से तालिकाओं पर उपयोग किया जाना है जो किसी भी उल्लिखित सूची में निर्दिष्ट नहीं है। यदि छोड़ा गया है, तो ऑपरेशन clear_tables का उपयोग किया जाता है।

प्रभावित तालिकाओं को पुनर्स्थापना के दौरान लिखा-बंद किया जाता है। हालांकि, इसके कारण होने वाले लॉक संघर्षों की परवाह किए बिना, एप्लिकेशन अपना काम करना जारी रख सकते हैं, जबकि बहाली का प्रदर्शन किया जा रहा है। बहाली एक एकल लेनदेन के रूप में की जाती है।

यदि डेटाबेस विशाल है, तो इसे ऑनलाइन पुनर्स्थापित करना हमेशा संभव नहीं होता है। ऐसे मामलों में, पुराने डेटाबेस को फॉलबैक इंस्टॉल करके पुनर्स्थापित करें और फिर पुनरारंभ करें।

s_delete ({टैब, की}) -> ठीक | लेन-देन गर्भपात

फ़ंक्शन को कॉल करता है mnesia:delete(Tab, Key, sticky_write)

s_delete_object (रिकॉर्ड) -> ठीक | लेन-देन गर्भपात

फ़ंक्शन को कॉल करता है mnesia:delete_object(Tab, Record, sticky_write) , जहां Tab है element(1, Record)

s_write (रिकॉर्ड) -> ठीक | लेन-देन गर्भपात

फ़ंक्शन को कॉल करता है mnesia:write(Tab, Record, sticky_write) , जहां Tab है element(1, Record)

स्कीमा () -> ठीक है

टर्मिनल पर सभी तालिका परिभाषाओं के बारे में जानकारी प्रिंट करता है।

स्कीमा (टैब) -> ठीक है

टर्मिनल पर एक तालिका परिभाषा के बारे में जानकारी प्रिंट करता है।

select (Tab, MatchSpec [, Lock]) -> लेन-देन गर्भपात | [वस्तु]

तालिका में वस्तुओं से मेल खाता है Tab एक का उपयोग कर match_spec में वर्णित के रूप ets:select/3 । वैकल्पिक रूप से एक ताला read या write तीसरे तर्क के रूप में दिया जा सकता है। डिफ़ॉल्ट है read । वापसी मूल्य पर निर्भर करता है MatchSpec

ध्यान दें कि सबसे अच्छे प्रदर्शन के लिए, select उसी लेनदेन में किसी तालिका में किसी भी प्रकार के संशोधित संचालन से पहले उपयोग किया जाना है। यही है, का उपयोग न करें write या delete पहले select

इसके सरलतम रूपों में, इस match_spec प्रकार है:

  • MatchSpec = [MatchFunction]
  • MatchFunction = {MatchHead, [Guard], [Result]}
  • MatchHead = tuple() | record()
  • Guard = {"Guardtest name", ...}
  • Result = "Term construct"

के पूर्ण विवरण के लिए select , STDLIB में ERTS उपयोगकर्ता गाइड और ets मैनुअल पेज देखें।

उदाहरण के लिए, तालिका में 30 वर्ष से अधिक आयु के सभी पुरुष व्यक्तियों के नाम खोजने के लिए Tab :

MatchHead = #person{name='$1', sex=male, age='$2', _='_'},
Guard = {'>', '$2', 30},
Result = '$1',
mnesia:select(Tab,[{MatchHead, [Guard], [Result]}]),
select (Tab, MatchSpec, NObjects, Lock) -> लेन-देन गर्भपात | {[वस्तु], कंट} | '$ End_of_table'

तालिका में ऑब्जेक्ट्स को उपयोगकर्ता के गाइड में वर्णित के रूप में Tab उपयोग match_spec करता है ERTS , और शर्तों और एक निरंतरता का एक हिस्सा देता है। लौटी हुई शर्तों की वांछित संख्या तर्क द्वारा निर्दिष्ट है NObjects । ताला तर्क read या हो सकता है write । निरंतरता को तर्क के रूप में उपयोग किया जाना है mnesia:select/1 , यदि अधिक या सभी उत्तरों की आवश्यकता है।

ध्यान दें कि सबसे अच्छे प्रदर्शन के लिए, select उसी लेनदेन में किसी तालिका में किसी भी प्रकार के संशोधित संचालन से पहले उपयोग किया जाना है। यही है, का उपयोग न करें mnesia:write या mnesia:delete पहले mnesia:select । दक्षता के लिए, NObjects केवल एक सिफारिश है और परिणाम में खाली सूची से सभी उपलब्ध परिणामों तक कुछ भी हो सकता है।

select (Cont) -> लेन-देन गर्भपात | {[वस्तु], कंट} | '$ End_of_table'

द्वारा शुरू किए गए मैच विनिर्देश के साथ अधिक वस्तुओं का चयन करता है mnesia:select/4

ध्यान दें कि परिणाम और कॉल के बीच किए गए कोई भी संशोधन, mnesia:write या mnesia:delete , परिणाम में दिखाई नहीं देते हैं। mnesia:select/4 mnesia:select/1

set_debug_level (स्तर) -> पुराना लिंक

मानेसिया के आंतरिक डिबग स्तर को बदलता है। जानकारी के लिए, देखें Section Configuration Parameters

set_master_nodes (MasterNodes) -> ठीक | {त्रुटि, कारण}

प्रत्येक तालिका के लिए मानेसिया अपनी प्रतिकृति नोड्स ( TabNodes ) निर्धारित करता है और शुरू होता है mnesia:set_master_nodes(Tab, TabMasterNodes) । जहां TabMasterNodes के चौराहे है MasterNodes और TabNodes । शब्दार्थ के लिए, देखें mnesia:set_master_nodes/2

set_master_nodes (टैब, मास्टरकोड) -> ठीक | {त्रुटि, कारण}

यदि एप्लिकेशन संचार विफलता (संभावित रूप से विभाजित नेटवर्क में) का पता लगाता है जो असंगत डेटाबेस का कारण हो सकता है, तो यह फ़ंक्शन mnesia:set_master_nodes(Tab, MasterNodes) का उपयोग यह परिभाषित करने के लिए कर सकता है कि प्रत्येक तालिका को किस नोड से लोड किया जाना है। स्टार्टअप पर, मानेसिया सामान्य टेबल लोड एल्गोरिथ्म को दरकिनार किया जाता है और तालिका को तालिका के लिए परिभाषित मास्टर नोड्स में से एक से लोड किया जाता है, भले ही अन्य नोड्स पर मेन्सिया को समाप्त कर दिया गया हो। MasterNodes केवल नोड्स हो सकते हैं जहां तालिका में एक प्रतिकृति है। यदि MasterNodes सूची खाली है, तो विशेष तालिका के लिए मास्टर नोड पुनर्प्राप्ति तंत्र रीसेट किया गया है, और अगले लोड पर सामान्य लोड तंत्र का उपयोग किया जाता है।

मास्टर नोड सेटिंग हमेशा स्थानीय होती है। चाहे मानेसिया शुरू हो या न हो, इसे बदला जा सकता है।

यदि कॉन्फ़िगरेशन पैरामीटर max_wait_for_decision का उपयोग किया जाता है या उपयोग किया जाता है तो डेटाबेस असंगत भी हो सकता mnesia:force_load_table/1 है।

snmp_close_table (टैब) -> {निरस्त, R} | {परमाणु, ठीक है}

तालिका में हेरफेर करने के लिए एसएनएमपी की संभावना को हटाता है।

snmp_get_mnesia_key (टैब, रोइंडेक्स) -> {ठीक है, कुंजी} | अपरिभाषित

प्रकार

इसी Mnesia कुंजी के लिए एक SNMP इंडेक्स ट्रांसफ़ॉर्म करता है। यदि SNMP तालिका में कई कुंजियाँ हैं, तो कुंजी कुंजी स्तंभों का एक टपल है।

snmp_get_next_index (टैब, रोइंडेक्स) -> {ठीक है, NextIndex} | endOfTable

प्रकार

RowIndex एक गैर-मौजूदा पंक्ति निर्दिष्ट कर सकता है। विशेष रूप से, यह खाली सूची हो सकती है। अगली लेक्सोग्राफ़िक पंक्ति का सूचकांक लौटाता है। यदि RowIndex खाली सूची है, तो यह फ़ंक्शन तालिका में पहली पंक्ति का सूचकांक लौटाता है।

snmp_get_row (टैब, रोइंडेक्स) -> {ठीक है, पंक्ति} | अपरिभाषित

प्रकार

अपने SNMP इंडेक्स द्वारा एक पंक्ति पढ़ता है। यह सूचकांक एक SNMP ऑब्जेक्ट आइडेंटिफ़ायर, पूर्णांक की एक सूची के रूप में निर्दिष्ट है।

snmp_open_table (टैब, SnmpStruct) -> {निरस्त, R} | {परमाणु, ठीक है}

प्रकार

मानेसिया तालिकाओं और एसएनएमपी तालिकाओं के बीच एक सीधा एक-से-एक मानचित्रण स्थापित किया जा सकता है। कई दूरसंचार अनुप्रयोगों को SNMP प्रोटोकॉल द्वारा नियंत्रित और मॉनिटर किया जाता है। मानेसिया और एसएनएमपी के बीच यह संबंध इस मानचित्रण को प्राप्त करने के लिए सरल और सुविधाजनक बनाता है।

तर्क SnmpStruct SNMP जानकारी की एक सूची है। वर्तमान में, केवल आवश्यक जानकारी तालिका में प्रमुख प्रकारों के बारे में जानकारी है। Mnesia में एकाधिक कुंजियों को संभाला नहीं जा सकता है, लेकिन कई SNMP तालिकाओं में कई कुंजियाँ होती हैं। इसलिए, निम्न सम्मेलन का उपयोग किया जाता है: यदि किसी तालिका में कई कुंजियाँ हैं, तो उन्हें हमेशा कुंजियों के टपल के रूप में संग्रहीत किया जाना चाहिए। प्रमुख प्रकारों के बारे में जानकारी प्रकारों का वर्णन करने वाले परमाणुओं के टपल के रूप में निर्दिष्ट की गई है। एकमात्र महत्वपूर्ण प्रकार है fix_string । इसका मतलब है कि एक स्ट्रिंग का एक निश्चित आकार है।

उदाहरण के लिए, person एसएनएमपी तालिका के रूप में निम्नलिखित कारणों से तालिका का आदेश दिया गया है:

mnesia:snmp_open_table(person, [{key, string}])

कंपनी के कर्मचारियों की एक तालिका के लिए निम्नलिखित स्कीमा पर विचार करें। प्रत्येक कर्मचारी की पहचान विभाग के नंबर और नाम से की जाती है। अन्य तालिका स्तंभ टेलीफोन नंबर संग्रहीत करता है:

mnesia:create_table(employee,
    [{snmp, [{key, {integer, string}}]},
     {attributes, record_info(fields, employees)}]),

इसी SNMP तालिका तीन कॉलम होगा: department , name , और telno

एक विकल्प टेबल कॉलम है जो SNMP प्रोटोकॉल के माध्यम से दिखाई नहीं देता है। ये कॉलम टेबल का आखिरी कॉलम होना चाहिए। पिछले उदाहरण में, एसएनएमपी तालिका में कॉलम department और name केवल हो सकते हैं । तब एप्लिकेशन telno आंतरिक रूप से कॉलम का उपयोग कर सकता था , लेकिन यह SNMP प्रबंधकों को दिखाई नहीं देगा।

एसएनएमपी द्वारा निगरानी की गई तालिका में, सभी तत्वों को पूर्णांक, तार या पूर्णांक की सूची होना चाहिए।

जब एक टेबल एसएनएमपी का आदेश दिया जाता है, तो संशोधन सामान्य से अधिक महंगे होते हैं, ओ (लॉगएन)। साथ ही, अधिक मेमोरी का उपयोग किया जाता है।

ध्यान दें कि केवल लेक्सोग्राफिक एसएनएमपी ऑर्डरिंग को मानेसिया में लागू किया गया है, न कि वास्तविक एसएनएमपी निगरानी।

start () -> ठीक है | {त्रुटि, कारण}

मानेसिया नोड्स के एक सेट के लिए स्टार्टअप प्रक्रिया काफी जटिल ऑपरेशन है। एक Mnesia प्रणाली में नोड्स का एक सेट होता है, जिसमें Mnesia सभी भाग लेने वाले नोड्स पर स्थानीय रूप से शुरू होता है। आम तौर पर, प्रत्येक नोड में एक निर्देशिका होती है जहां सभी मेन्सिया फाइलें लिखी जाती हैं। इस निर्देशिका को Mnesia निर्देशिका कहा जाता है। मेन्शिया को डिस्क-कम नोड्स पर भी शुरू किया जा सकता है। डिस्क-कम नोड्स के बारे में अधिक जानकारी के लिए, mnesia:create_schema/1 उपयोगकर्ता की मार्गदर्शिका देखें।

नोड्स का सेट जो एक Mnesia सिस्टम बनाता है, स्कीमा में रखा जाता है। मेन्शिया नोड्स को स्कीमा से जोड़ा या हटाया जा सकता है। प्रारंभिक स्कीमा आम तौर पर फ़ंक्शन के साथ डिस्क पर बनाई जाती है mnesia:create_schema/1 । डिस्क-कम नोड्स पर, Mnesia शुरू होने पर हर बार एक छोटा डिफ़ॉल्ट स्कीमा उत्पन्न होता है। स्टार्टअप प्रक्रिया के दौरान, Mnesia नोड्स के बीच स्कीमा जानकारी का आदान-प्रदान करने के लिए सत्यापित करता है कि तालिका की परिभाषाएँ संगत हैं।

प्रत्येक स्कीमा में एक अद्वितीय कुकी होती है, जिसे एक विशिष्ट स्कीमा पहचानकर्ता माना जा सकता है। कुकी को सभी नोड्स पर समान होना चाहिए जहां मानेसिया को चलाना है। विवरण के लिए, उपयोगकर्ता की मार्गदर्शिका देखें।

स्कीमा फ़ाइल और अन्य सभी फाइलें जो Mnesia की ज़रूरत होती हैं उन्हें Mnesia डायरेक्टरी में रखी जाती हैं। -mnesia dir Dir इस निर्देशिका के स्थान को Mnesia सिस्टम में निर्दिष्ट करने के लिए कमांड-लाइन विकल्प का उपयोग किया जा सकता है। यदि ऐसा कोई कमांड-लाइन विकल्प नहीं मिलता है, तो निर्देशिका का नाम चूक जाता है Mnesia.Node

application:start(mnesia) भी इस्तेमाल किया जा सकता है।

stop () -> रुका हुआ

स्थानीय स्तर पर Mnesia को रोकता है।

application:stop(mnesia) भी इस्तेमाल किया जा सकता है।

subscribe (EventCategory) -> {ठीक है, नोड} | {त्रुटि, कारण}

यह सुनिश्चित करता है कि EventCategory कॉल करने वाले को सभी प्रकार की घटनाओं की एक प्रति भेजी जाए। उपलब्ध घटना प्रकारों में वर्णित हैं User's Guide

Sync_dirty (मज़ा, [, Args]) -> ResultOfFun | बाहर निकलने के (कारण)

Fun एक संदर्भ में कॉल करता है जो लेनदेन द्वारा संरक्षित नहीं है। Mnesia फ़ंक्शन कॉल में प्रदर्शन Fun गंदे कार्यों के लिए मैप किए जाते हैं। यह लगभग उसी संदर्भ में किया जाता है जैसे mnesia:async_dirty/1,2 । अंतर यह है कि संचालन समकालिक रूप से किया जाता है। कॉलर Fun रिटर्न के पहले सभी सक्रिय प्रतिकृतियों पर किए जाने वाले अद्यतनों की प्रतीक्षा करता है। विवरण के लिए, देखें mnesia:activity/4 और उपयोगकर्ता की मार्गदर्शिका।

Sync_log () -> ठीक | {त्रुटि, कारण}

सुनिश्चित करता है कि स्थानीय लेन-देन लॉग फ़ाइल डिस्क के लिए समन्वयित है। एकल नोड सिस्टम पर, अंतिम डंप के बाद से डिस्क तालिकाओं पर लिखा गया डेटा खो सकता है यदि बिजली आउटेज है। देख लो dump_log/0

Sync_transaction (मज़ा, [[, आर्ग्स], रिट्रीट]) -> {निरस्त, कारण} | {परमाणु, रिजल्टऑफफुन}

प्रतीक्षा करता है जब तक कि डेटा को कमिट नहीं किया गया है और डिस्क (यदि डिस्क का उपयोग किया जाता है) पर लौटने से पहले हर शामिल नोड पर, अन्यथा यह व्यवहार करता है mnesia:transaction/[1,2,3]

इस कार्यशीलता का उपयोग इस बात से बचने के लिए किया जा सकता है कि एक प्रक्रिया दूसरे नोड पर एक डेटाबेस को अधिभारित करती है।

system_info (InfoKey) -> जानकारी | बाहर निकलें ({निरस्त, कारण})

Mnesia प्रणाली के बारे में जानकारी लौटाता है, जैसे लेन-देन के आँकड़े db_nodes और कॉन्फ़िगरेशन पैरामीटर। मान्य कुंजी इस प्रकार हैं:

  • all । सभी स्थानीय सिस्टम जानकारी की सूची लौटाता है। प्रत्येक तत्व एक {InfoKey, InfoVal} टपल है।

    नया InfoKey एस जोड़ा जा सकता है और पुराने अनिर्दिष्ट InfoKey एस को बिना सूचना के हटाया जा सकता है।

  • access_module । मॉड्यूल का नाम लौटाता है जो गतिविधि एक्सेस कॉलबैक मॉड्यूल होने के लिए कॉन्फ़िगर किया गया है।

  • auto_repair । रिटर्न true या false यह इंगित करने के लिए कि क्या मेन्शिया को दूषित डिस्क फ़ाइलों पर ऑटो-मरम्मत सुविधा शुरू करने के लिए कॉन्फ़िगर किया गया है।

  • backup_module । बैकअप कॉलबैक मॉड्यूल होने के लिए कॉन्फ़िगर किए गए मॉड्यूल का नाम देता है।

  • checkpoints । इस नोड पर वर्तमान में सक्रिय चौकियों के नामों की सूची लौटाता है।

  • event_module । मॉड्यूल का नाम देता है जो ईवेंट हैंडलर कॉलबैक मॉड्यूल है।

  • db_nodes । उन नोड्स को लौटाता है जो लगातार डेटाबेस बनाते हैं। डिस्क-कम नोड्स केवल नोड्स की सूची में शामिल हैं यदि उन्हें स्पष्ट रूप से स्कीमा में जोड़ा गया है, उदाहरण के लिए, के साथ mnesia:add_table_copy/3 । समारोह शुरू किया जा सकता है, भले ही मानेसिया अभी तक नहीं चल रहा हो।

  • debug । Mnesia का वर्तमान डिबग स्तर लौटाता है।

  • directory । Mnesia निर्देशिका का नाम देता है। इसे तब भी कहा जा सकता है जब मानेसिया अभी तक नहीं चल रहा है।

  • dump_log_load_regulation । एक बूलियन लौटाता है जो बताता है कि क्या मंसिया को डम्पर प्रक्रिया लोड को विनियमित करने के लिए कॉन्फ़िगर किया गया है।

    यह सुविधा अस्थायी है और भविष्य के रिलीज़ में हटा दी जाएगी।

  • dump_log_time_threshold । मिलीसेकंड में लेन-देन लॉग डंप के लिए समय सीमा लौटाता है।

  • dump_log_update_in_place । एक बूलियन लौटाता है जो बताता है कि Metsia को Dets फ़ाइलों में सीधे अपडेट करने के लिए कॉन्फ़िगर किया गया है, या यदि अपडेट Dets फ़ाइलों की प्रतिलिपि में किए जाने हैं।

  • dump_log_write_threshold । लेनदेन लॉग के लिए लिखने की संख्या के रूप में लेन-देन लॉग डंप के लिए थ्रेशोल्ड लौटाता है।

  • extra_db_nodes db_nodes स्टार्टअप पर संपर्क करने के लिए अतिरिक्त की सूची लौटाता है ।

  • fallback_activated true यदि कोई कमबैक सक्रिय है, तो वापस लौटाता है false

  • held_locks । स्थानीय मानेसिया ताला प्रबंधक द्वारा रखे गए सभी तालों की सूची देता है।

  • is_running । वापसी yes या no इंगित करने के लिए कि मानेसिया चल रहा है। यह भी लौट सकते हैं starting या stopping । कहा जा सकता है भले ही मानेसिया अभी तक नहीं चल रहा है।

  • local_tables । स्थानीय रूप से निवास करने के लिए कॉन्फ़िगर किए गए सभी तालिकाओं की सूची लौटाता है।

  • lock_queue । उन सभी लेन-देन की सूची लौटाता है जो स्थानीय लॉक मैनेजर द्वारा निष्पादन के लिए कतारबद्ध हैं।

  • log_version । Mnesia ट्रांजेक्शन लॉग फॉर्मेट का वर्जन नंबर लौटाता है।

  • master_node_tables । कम से कम एक मास्टर नोड के साथ सभी तालिकाओं की सूची लौटाता है।

  • protocol_version । Mnesia इंटर-प्रोसेस संचार प्रोटोकॉल के संस्करण संख्या को लौटाता है।

  • running_db_nodes । उन नोड्स की सूची लौटाता है, जहां Mnesia वर्तमान में चल रहा है। यह फ़ंक्शन तब भी कहा जा सकता है, जब मानेसिया अभी तक नहीं चल रहा है, लेकिन इसके बाद थोड़ा अलग शब्दार्थ है।

    यदि मेन्सिया स्थानीय नोड पर है, तो फ़ंक्शन उन दूसरे को लौटाता है db_nodes और extra_db_nodes जो फिलहाल चालू हैं।

    यदि मेन्सिया शुरू किया जाता है, तो फ़ंक्शन उन नोड्स को वापस करता है जो स्थानीय नोड पर मेन्सिया पूरी तरह से जुड़ा हुआ है। केवल उन नोड्स जो Mnesia ने स्कीमा जानकारी का आदान-प्रदान किया है, के रूप में शामिल हैं running_db_nodes । स्कीमा के विलय के बाद, स्थानीय मानेसिया प्रणाली पूरी तरह से संचालित होती है और अनुप्रयोग दूरस्थ प्रतिकृति की पहुंच का प्रदर्शन कर सकते हैं। स्कीमा विलय से पहले, मानेसिया केवल स्थानीय रूप से संचालित होता है। कभी-कभी running_db_nodes सूची में सभी db_nodes और extra_db_nodes एक साथ अधिक नोड्स शामिल होते हैं।

  • schema_location । प्रारंभिक स्कीमा स्थान लौटाता है।

  • subscribers । वर्तमान में सिस्टम ईवेंट की सदस्यता लेने वाली स्थानीय प्रक्रियाओं की सूची लौटाता है।

  • tables । सभी स्थानीय रूप से ज्ञात तालिकाओं की सूची लौटाता है।

  • transactions । वर्तमान में सक्रिय सभी स्थानीय लेनदेन की सूची लौटाता है।

  • transaction_failures । एक संख्या देता है जो इंगित करता है कि मेन्शिया शुरू होने के बाद से कितने लेनदेन विफल हो गए हैं।

  • transaction_commits । एक संख्या देता है जो इंगित करता है कि मेन्शिया शुरू होने के बाद से कितने लेनदेन सफलतापूर्वक समाप्त हो गए हैं।

  • transaction_restarts । एक संख्या देता है जो इंगित करता है कि मेन्शिया शुरू होने के बाद से कितने लेनदेन फिर से शुरू हो गए हैं।

  • transaction_log_writes । एक संख्या देता है जो इंगित करता है कि स्टार्टअप के बाद से लेन-देन लॉग में कितने लेखन कार्य किए गए हैं।

  • use_dir । एक बूलियन देता है जो इंगित करता है कि मानेसिया निर्देशिका का उपयोग किया जाता है या नहीं। शुरू किया जा सकता है भले ही मानेसिया अभी तक नहीं चल रहा है।

  • version । Mnesia की वर्तमान संस्करण संख्या लौटाता है।

तालिका (टैब [, [विकल्प]]) -> क्वेरीहैंडल

एक क्वेरी सूची समझ (QLC) क्वेरी हैंडल qlc(3) लौटाता है, STDLIB में मैनुअल पेज देखें । मॉड्यूल qlc एक क्वेरी भाषा को लागू करता है जो डेटा के स्रोतों के रूप में मानेसिया तालिकाओं का उपयोग कर सकता है। कॉलिंग QLC के mnesia:table/1,2 लिए mnesia तालिका को Tab उपयोगी बनाने का साधन है ।

Option Mnesia विकल्प या QLC विकल्प हो सकते हैं। Mnesia निम्नलिखित विकल्पों को पहचानता है (कोई अन्य विकल्प QLC को अग्रेषित किया जाता है)।

  • {lock, Lock} , जहां या lock हो सकता है । डिफ़ॉल्ट है । read write read
  • {n_objects,Number} , जहाँ n_objects निर्दिष्ट करता है (मोटे तौर पर) Mnesia से QLC में लौटी वस्तुओं की संख्या। रिमोट टेबल के लिए क्वेरीज़ को नेटवर्क ओवरहेड को कम करने के लिए एक बड़े हिस्से की आवश्यकता हो सकती है। डिफ़ॉल्ट रूप से, 100 एक समय में ऑब्जेक्ट वापस आ जाते हैं।
  • {traverse, SelectMethod} , जहां traverse संपूर्ण तालिका (यदि आवश्यक हो) को पार करने की विधि निर्धारित करता है। डिफ़ॉल्ट विधि है select

इसके लिए दो विकल्प हैं select :

  • select । तालिका को कॉल करके ट्रेस किया जाता है mnesia:select/4 और mnesia:select/1 । मैच स्पेसिफिकेशन (का दूसरा तर्क select/3 ) QLC द्वारा इकट्ठा किया गया है: साधारण फ़िल्टर को बराबर मिलान विनिर्देशों में अनुवादित किया जाता है। सभी ऑब्जेक्ट्स से select/3 मेल खाने वाले मैच विनिर्देश द्वारा लौटाए गए सभी ऑब्जेक्ट्स पर अधिक जटिल फ़िल्टर लागू करने की आवश्यकता है ।

  • {select, MatchSpec} । के रूप में select , मेज पर फोन करके पता लगाया गया है mnesia:select/3 और mnesia:select/1 । अंतर यह है कि मैच विनिर्देश स्पष्ट रूप से दिया गया है। यह कैसे मैच विशेषताओं को निर्दिष्ट करता है जो आसानी से QLC द्वारा प्रदान किए गए सिंटैक्स के भीतर व्यक्त नहीं किया जा सकता है।

table_info (टैब, InfoKey) -> जानकारी | बाहर निकलें ({निरस्त, कारण})

table_info/2 समारोह दो तर्क लेता है। पहला एक मानेसिया तालिका का नाम है। दूसरा निम्नलिखित कुंजियों में से एक है:

  • all । सभी स्थानीय तालिका जानकारी की एक सूची देता है। प्रत्येक तत्व एक {InfoKey, ItemVal} टपल है।

    नया InfoItem एस जोड़ा जा सकता है और पुराने अनिर्दिष्ट InfoItem एस को बिना सूचना के हटाया जा सकता है।

  • access_mode । तालिका की पहुँच मोड लौटाता है। पहुंच मोड read_only या हो सकता है read_write

  • arity । स्कीमा में निर्दिष्ट अनुसार तालिका में अभिलेखों की शुद्धता लौटाता है।

  • attributes । स्कीमा में निर्दिष्ट तालिका विशेषता नाम लौटाता है।

  • checkpoints । वर्तमान में सक्रिय चौकियों के नाम लौटाता है, जिसमें इस नोड पर तालिका शामिल है।

  • cookie । एक टेबल कुकी लौटाता है, जो तालिका के लिए एक अद्वितीय सिस्टम-जनरेटेड पहचानकर्ता है। कुकी का उपयोग आंतरिक रूप से यह सुनिश्चित करने के लिए किया जाता है कि एक ही तालिका नाम का उपयोग करके दो अलग-अलग तालिका परिभाषाएं गलती से रुक-रुक कर नहीं हो सकती हैं। प्रारंभ में तालिका बनाए जाने पर कुकी उत्पन्न होती है।

  • disc_copies । नोड्स को लौटाता है जहां disc_copy स्कीमा के अनुसार तालिका का एक निवास करता है।

  • disc_only_copies । नोड्स को लौटाता है जहां disc_only_copy स्कीमा के अनुसार तालिका का एक निवास करता है।

  • index । तालिका के लिए अनुक्रमणिका स्थिति पूर्णांकों की सूची लौटाता है।

  • load_node । उस नोड का नाम लौटाता है जिससे मानेसिया ने तालिका लोड की थी। लौटाए गए मूल्य की संरचना अनिर्दिष्ट है, लेकिन डिबगिंग उद्देश्यों के लिए उपयोगी हो सकती है।

  • load_order । तालिका के लोड ऑर्डर प्राथमिकता को लौटाता है। यह एक पूर्णांक और डिफॉल्ट 0 (शून्य) है।

  • load_reason । वापसी का कारण है कि मानेसिया ने तालिका को लोड करने का निर्णय लिया। लौटाए गए मूल्य की संरचना अनिर्दिष्ट है, लेकिन डिबगिंग उद्देश्यों के लिए उपयोगी हो सकती है।

  • local_content । रिटर्न true या false इंगित करने के लिए कि क्या प्रत्येक नोड पर स्थानीय रूप से अद्वितीय सामग्री होने के लिए तालिका कॉन्फ़िगर की गई है।

  • master_nodes । एक तालिका के मास्टर नोड्स लौटाता है।

  • memory । इस नोड पर तालिका में आवंटित शब्दों की संख्या लौटाता है।

  • ram_copies । नोड्स को लौटाता है जहां ram_copy स्कीमा के अनुसार तालिका का एक निवास करता है।

  • record_name । तालिका में सभी रिकॉर्ड के लिए सामान्य रिकॉर्ड नाम लौटाता है।

  • size । तालिका में सम्मिलित रिकॉर्ड की संख्या लौटाता है।

  • snmp । SNMP संरचना लौटाता है। [] इसका मतलब है कि तालिका में वर्तमान में कोई SNMP गुण नहीं है।

  • storage_type । तालिका का स्थानीय संग्रहण प्रकार लौटाता है। यह हो सकता है disc_copies , ram_copies , disc_only_copies , या परमाणु unknown unknown सभी तालिकाओं के लिए लौटा है जो केवल दूरस्थ रूप से रहते हैं।

  • subscribers । वर्तमान में इस तालिका में इस तालिका में शामिल होने वाली स्थानीय तालिका घटनाओं की सदस्यता लेने वाली स्थानीय प्रक्रियाओं की एक सूची देता है।

  • type । तालिका प्रकार है, जो है देता है bag , set या ordered_set

  • user_properties । तालिका से उपयोगकर्ता-संबंधित तालिका गुण देता है। यह संग्रहित संपत्ति रिकॉर्ड की एक सूची है।

  • version । तालिका परिभाषा का वर्तमान संस्करण लौटाता है। तालिका की परिभाषा बदलने पर तालिका संस्करण बढ़ जाता है। तालिका परिभाषा को सीधे तब बढ़ाया जा सकता है जब इसे स्कीमा लेनदेन में बदल दिया गया हो, या जब स्टार्टअप के दौरान अन्य नोड्स से तालिका परिभाषाओं के साथ एक प्रतिबद्ध तालिका परिभाषा को मिला दिया गया हो।

  • where_to_read । उस नोड को लौटाता है जहाँ तालिका को पढ़ा जा सकता है। यदि मान nowhere लौटाया जाता है, तो या तो तालिका लोड नहीं होती है या यह एक दूरस्थ नोड पर रहता है जो नहीं चल रहा है।

  • where_to_write । उन नोड्स की सूची लौटाता है जो वर्तमान में तालिका की सक्रिय प्रतिकृति रखते हैं।

  • wild_pattern । एक संरचना देता है जो एक निश्चित तालिका के लिए विभिन्न मैच फ़ंक्शन को दिया जा सकता है। एक रिकॉर्ड ट्यूपल वह जगह है जहां सभी रिकॉर्ड फ़ील्ड का मान होता है '_'

लेन-देन (मज़ा [[, आर्ग्स], रिट्रीट]) -> {निरस्त, कारण} | {परमाणु, रिजल्टऑफफुन}

लेन-देन के रूप में Fun तर्कों के साथ कार्यात्मक वस्तु को निष्पादित करता है Args

कोड जो लेनदेन के अंदर निष्पादित होता है, उसमें तालिका हेरफेर कार्यों की एक श्रृंखला शामिल हो सकती है। यदि उपयोगकर्ता त्रुटि या निश्चित तालिका उपलब्ध नहीं होने के परिणामस्वरूप लेनदेन के अंदर कुछ गलत हो जाता है, तो संपूर्ण लेनदेन समाप्त हो जाता है और फ़ंक्शन transaction/1 टपल को वापस कर देता है {aborted, Reason}

यदि सब ठीक चल रहा है, {atomic, ResultOfFun} तो लौटा दिया जाता है, जहां ResultOfFun अंतिम अभिव्यक्ति का मूल्य है Fun

एक फ़ंक्शन जो डेटाबेस में एक परिवार जोड़ता है, उसे इस प्रकार लिखा जा सकता है यदि कोई संरचना है {family, Father, Mother, ChildrenList} :

add_family({family, F, M, Children}) ->
    ChildOids = lists:map(fun oid/1, Children),
    Trans = fun() ->      
        mnesia:write(F#person{children = ChildOids}, 
        mnesia:write(M#person{children = ChildOids},
        Write = fun(Child) -> mnesia:write(Child) end,
        lists:foreach(Write, Children)
    end,
    mnesia:transaction(Trans).

oid(Rec) -> {element(1, Rec), element(2, Rec)}.

यह कोड डेटाबेस में लोगों का एक सेट जोड़ता है। एक लेन-देन के भीतर इस कोड को चलाना सुनिश्चित करता है कि या तो पूरे परिवार को डेटाबेस में जोड़ा जाए, या पूरे लेनदेन को समाप्त कर दिया जाए। उदाहरण के लिए, यदि अंतिम बच्चे को बुरी तरह से स्वरूपित किया गया है, या क्रियान्वयन प्रक्रिया 'EXIT' परिवार कोड को निष्पादित करते समय एक संकेत के कारण समाप्त हो जाती है , तो लेनदेन समाप्त हो जाता है। इस प्रकार, ऐसी स्थिति जहां आधा परिवार जोड़ा जाता है, कभी नहीं हो सकता है।

यदि किसी प्रक्रिया में समवर्ती रिकॉर्ड को समान रूप से अपडेट किया जाता है तो लेनदेन के भीतर डेटाबेस को अपडेट करना भी उपयोगी है। उदाहरण के लिए, फ़ंक्शन raise(Name, Amount) , जो Amount किसी व्यक्ति के वेतन क्षेत्र में जोड़ता है, को निम्नानुसार लागू किया जाना है:

raise(Name, Amount) ->
    mnesia:transaction(fun() ->
        case mnesia:wread({person, Name}) of
            [P] ->
                Salary = Amount + P#person.salary,
                P2 = P#person{salary = Salary},
                mnesia:write(P2);
            _ ->
                mnesia:abort("No such person")
        end
    end).

जब यह फ़ंक्शन लेन-देन के भीतर निष्पादित होता है, तो विभिन्न नोड्स पर चलने वाली कई प्रक्रियाएं raise/2 एक दूसरे के साथ हस्तक्षेप किए बिना फ़ंक्शन को समवर्ती रूप से निष्पादित कर सकती हैं ।

चूंकि मान्सिया गतिरोध का पता लगाता है, इसलिए किसी भी समय किसी भी लेनदेन को फिर से शुरू किया जा सकता है। यह फ़ंक्शन निर्दिष्ट किए गए अनुसार पुनः आरंभ करने का प्रयास करता है Retries Retries 0 या परमाणु से अधिक पूर्णांक होना चाहिए infinity । डिफ़ॉल्ट infinity

ट्रांसफॉर्म_टेबल (टैब, फन, न्यूएट्रिब्यूटलीस्ट, न्यूक्रॉन्डनेम) -> {निरस्त, आर} | {परमाणु, ठीक है}

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

NewAttributeList और NewRecordName विशेषताओं और परिवर्तित तालिका के नए रिकॉर्ड प्रकार को निर्दिष्ट करें। तालिका का नाम हमेशा अपरिवर्तित रहता है। यदि record_name बदला गया है, तो केवल Mnesia फ़ंक्शन जो टेबल आइडेंटिफ़ायर काम का उपयोग mnesia:write/3 करता है, उदाहरण के लिए, काम करता है, लेकिन नहीं mnesia:write/1

ट्रांसफॉर्म_टेबल (टैब, फन, न्यूएट्रिब्यूटलिस्ट) -> {निरस्त, आर} | {परमाणु, ठीक है}

कहता है mnesia:transform_table(Tab, Fun, NewAttributeList, RecName) , जहां RecName है mnesia:table_info(Tab, record_name)

traverse_backup (स्रोत, [SourceMod,] लक्ष्य, [TargetMod,] मज़ा, Acc) -> {ठीक है, LastAcc} | {त्रुटि, कारण}

एक बैकअप पर Iterates, या तो इसे एक नए बैकअप में बदलने के लिए, या इसे पढ़ें। तर्कों को यहां संक्षेप में समझाया गया है। विवरण के लिए, उपयोगकर्ता की मार्गदर्शिका देखें।

  • SourceMod और TargetMod मॉड्यूल के नाम हैं जो वास्तव में बैकअप मीडिया तक पहुंचते हैं।
  • Source और Target अपारदर्शी डेटा विशेष रूप से मॉड्यूल द्वारा उपयोग किया जाता है SourceMod और TargetMod बैकअप मीडिया को इनिशियलाइज़ करने के लिए।
  • Acc एक प्रारंभिक संचायक मान है।
  • Fun(BackupItems, Acc) बैकअप में प्रत्येक आइटम पर लागू होता है। Fun एक टपल लौटना चाहिए {BackupItems,NewAcc} , जहां BackupItems वैध बैकअप मदों की एक सूची है, और NewAcc एक नया संचायक मूल्य है। लौटे बैकअप आइटम लक्ष्य बैकअप में लिखे गए हैं।
  • LastAcc अंतिम संचायक मान है। यह अंतिम NewAcc मान है जो इसके द्वारा लौटाया गया था Fun
uninstall_fallback () -> ठीक | {त्रुटि, कारण}

फ़ंक्शन को कॉल करता है mnesia:uninstall_fallback([{scope, global}])

uninstall_fallback (आर्ग्स) -> ठीक है | {त्रुटि, कारण}

डेटाबेस को पुनर्स्थापित करने के लिए इसका उपयोग करने से पहले एक गिरावट का संकेत देता है। यह आम तौर पर एक वितरित ऑपरेशन है जो या तो डिस्क निवासी स्कीमा के साथ सभी नोड्स पर किया जाता है, या कोई भी नहीं। फालबैक की स्थापना के लिए सभी सम्मिलित नोड्स पर Erlang का संचालन होना आवश्यक है, लेकिन इससे कोई फर्क नहीं पड़ता कि Mnesia चल रहा है या नहीं। डिस्क-रेजिडेंट नोड्स के रूप में माने जाने वाले नोड्स को स्थानीय कमबैक में स्कीमा जानकारी से निर्धारित किया जाता है।

Args निम्नलिखित ट्यूपल्स की एक सूची है:

  • {module, BackupMod} । शब्दार्थ के लिए, देखें mnesia:install_fallback/2
  • {scope, Scope} । शब्दार्थ के लिए, देखें mnesia:install_fallback/2
  • {mnesia_dir, AlternateDir} । शब्दार्थ के लिए, देखें mnesia:install_fallback/2
unsubscribe (EventCategory) -> {ठीक है, नोड} | {त्रुटि, कारण}

EventCategory फोन करने वाले को प्रकार की घटनाओं को भेजने से रोकता है ।

Node स्थानीय नोड है।

Wait_for_tables (टैबलिस्ट, टाइमआउट) -> ठीक है | {टाइमआउट, बैडबलिस्ट} | {त्रुटि, कारण}

कुछ एप्लिकेशन को उपयोगी कार्य करने के लिए कुछ तालिकाओं के सुलभ होने की प्रतीक्षा करने की आवश्यकता होती है। mnesia:wait_for_tables/2 या तो तब तक लटके रहे जब तक कि सभी टेबल TabList सुलभ न हों, या जब तक timeout पहुंच न जाए।

wread ({टैब, की}) -> लेन-देन गर्भपात | RecordList

फ़ंक्शन को कॉल करता है mnesia:read(Tab, Key, write)

लिखना (रिकॉर्ड) -> लेन-देन गर्भपात | ठीक

फ़ंक्शन को कॉल करता है mnesia:write(Tab, Record, write) , जहां Tab है element(1, Record)

लिखने (टैब, रिकॉर्ड, LockKind) -> लेनदेन गर्भपात | ठीक

Record तालिका में रिकॉर्ड लिखते हैं Tab

ok यदि कोई त्रुटि होती है, तो फ़ंक्शन वापस आ जाता है या समाप्त हो जाता है। उदाहरण के लिए, लेनदेन समाप्त हो जाता है यदि कोई person तालिका मौजूद नहीं है।

इस फ़ंक्शन का शब्दार्थ संदर्भ-संवेदनशील है। जानकारी के लिए, देखें mnesia:activity/4 । लेन-देन-संदर्भ में, यह एक प्रकार का लॉक प्राप्त करता है LockKind । लॉक प्रकार write और sticky_write समर्थित हैं।

write_lock_table (टैब) -> ठीक है | लेन-देन गर्भपात

फ़ंक्शन को कॉल करता है mnesia:lock({table, Tab}, write)

कॉन्फ़िगरेशन पैरामीटर

Mnesia निम्नलिखित अनुप्रयोग कॉन्फ़िगरेशन पैरामीटर पढ़ता है:

  • -mnesia access_module Module । मानेसिया गतिविधि एक्सेस कॉलबैक मॉड्यूल का नाम। डिफ़ॉल्ट है mnesia

  • -mnesia auto_repair true | false -mnesia auto_repair true | false । यह ध्वज नियंत्रित करता है यदि मानेसिया स्वचालित रूप से उन फ़ाइलों को ठीक करने की कोशिश करता है जो ठीक से बंद नहीं हुए हैं। डिफ़ॉल्ट true

  • -mnesia backup_module Module । Mnesia बैकअप कॉलबैक मॉड्यूल का नाम। डिफ़ॉल्ट है mnesia_backup

  • -mnesia debug Level । Mnesia के डिबग स्तर को नियंत्रित करता है। संभावित मूल्य इस प्रकार हैं:

    none

    कोई ट्रेस आउटपुट नहीं। यह डिफ़ॉल्ट है।

    verbose

    महत्वपूर्ण डिबग घटनाओं के अनुरेखण को सक्रिय करता है। ये ईवेंट {mnesia_info, Format, Args} सिस्टम ईवेंट उत्पन्न करते हैं। प्रक्रियाओं के साथ इन घटनाओं की सदस्यता ले सकते हैं mnesia:subscribe/1 । इवेंट्स को हमेशा मानेसिया इवेंट हैंडलर के पास भेजा जाता है।

    debug

    वर्बोज़ स्तर पर सभी घटनाओं को सक्रिय करता है और सभी डिबग घटनाओं के पूर्ण निशान। ये डीबग इवेंट {mnesia_info, Format, Args} सिस्टम ईवेंट उत्पन्न करते हैं। प्रक्रियाओं के साथ इन घटनाओं की सदस्यता ले सकते हैं mnesia:subscribe/1 । इवेंट्स को हमेशा मानेसिया इवेंट हैंडलर के पास भेजा जाता है। इस डिबग स्तर पर, Mnesia ईवेंट हैंडलर स्कीमा तालिका में अद्यतनों की सदस्यता लेना शुरू कर देता है।

    trace

    डिबग स्तर पर सभी घटनाओं को सक्रिय करता है। इस स्तर पर, Mnesia इवेंट हैंडलर सभी Mnesia टेबल पर अपडेट की सदस्यता लेना शुरू कर देता है। यह स्तर केवल छोटे खिलौना सिस्टम को डीबग करने के लिए है, क्योंकि कई बड़ी घटनाओं को उत्पन्न किया जा सकता है।

    false
    कोई नहीं के लिए एक उपनाम।
    true
    डिबग के लिए एक उपनाम।
  • -mnesia core_dir Directory । उस निर्देशिका का नाम जहां Mnesia कोर फाइलें संग्रहीत हैं, या गलत हैं। यह सेट करने से तात्पर्य यह है कि यदि कोई दुर्घटना होती है तो रैम-केवल नोड्स एक कोर फ़ाइल उत्पन्न करते हैं।

  • -mnesia dc_dump_limit Number disc_copies स्मृति से कितनी बार तालिकाओं को नियंत्रित किया जाता है । टेबल्स को जब डंप किया जाता है filesize(Log) > (filesize(Tab)/Dc_dump_limit) । निम्न मान CPU ओवरहेड को कम करते हैं लेकिन डिस्क स्थान और स्टार्टअप समय बढ़ाते हैं। डिफ़ॉल्ट 4 है।

  • -mnesia dir Directory । उस निर्देशिका का नाम जहां सभी Mnesia डेटा संग्रहीत हैं। वर्तमान नोड के लिए निर्देशिका नाम अद्वितीय होना चाहिए। दो नोड्स को एक ही Mnesia निर्देशिका को कभी भी साझा नहीं करना चाहिए। परिणाम अप्रत्याशित हैं।

  • -mnesia dump_disc_copies_at_startup true | false -mnesia dump_disc_copies_at_startup true | false । यदि इसे गलत पर सेट किया जाता है, तो यह disc_copies स्टार्टअप के दौरान तालिकाओं के डंपिंग को निष्क्रिय कर देता है जबकि तालिकाओं को लोड किया जा रहा है। डिफ़ॉल्ट सत्य है।

  • -mnesia dump_log_load_regulation true | false -mnesia dump_log_load_regulation true | false । लॉग डंप होने पर नियंत्रण जितना संभव हो उतना तेजी से किया जाना चाहिए, या यदि डम्पर को अपना लोड विनियमन करना है। डिफ़ॉल्ट false

    यह सुविधा अस्थायी है और भविष्य के रिलीज़ में हटा दी जाएगी

  • -mnesia dump_log_update_in_place true | false -mnesia dump_log_update_in_place true | false । नियंत्रण यदि लॉग डंप मूल डेटा फ़ाइल की एक प्रति पर किया जाता है, या यदि लॉग डंप मूल डेटा फ़ाइल पर किया जाता है। डिफ़ॉल्ट है true

  • -mnesia dump_log_write_threshold Max Max एक पूर्णांक है, जो लॉग के एक नए डंप के प्रदर्शन से पहले लेनदेन लॉग को अधिकतम लिखने की अनुमति देता है। डिफ़ॉल्ट 100 लॉग लिखता है।

  • -mnesia dump_log_time_threshold Max Max एक पूर्णांक है जो मिलीसेकंड में डंप लॉग अंतराल को निर्दिष्ट करता है। डिफ़ॉल्ट 3 मिनट है। यदि dump_log_time_threshold मिलीसेकंड के भीतर कोई डंप नहीं किया गया है , तो एक नया डंप प्रदर्शन की संख्या की परवाह किए बिना किया जाता है।

  • -mnesia event_module Module । मानेसिया इवेंट हैंडलर कॉलबैक मॉड्यूल का नाम। डिफ़ॉल्ट है mnesia_event

  • -mnesia extra_db_nodes Nodes स्कीमा में पाए गए लोगों के अलावा, नोड्स की एक सूची को निर्दिष्ट करता है, जिसके साथ मानेसिया भी संपर्क स्थापित करने के लिए है। डिफ़ॉल्ट [] (खाली सूची) है।

  • -mnesia fallback_error_function {UserModule, UserFunc} । एक उपयोगकर्ता द्वारा आपूर्ति की गई कॉलबैक फ़ंक्शन को निर्दिष्ट करता है, जिसे कहा जाता है कि क्या एक फॉलबैक स्थापित है और मेन्सिया दूसरे नोड पर नीचे जाता है। Mnesia फ़ंक्शन को एक तर्क के साथ कहता है, मरने वाले नोड का नाम, उदाहरण के लिए UserModule:UserFunc(DyingNode) ,। मेन्सिया को फिर से शुरू करना होगा, अन्यथा डेटाबेस असंगत हो सकता है। डिफ़ॉल्ट व्यवहार Mnesia को समाप्त करना है।

  • -mnesia max_wait_for_decision Timeout । निर्दिष्ट करता है कि एक स्पष्ट लेनदेन के परिणाम के बारे में अपने ज्ञान को साझा करने के लिए मानेसिया अन्य नोड्स का कितना समय इंतजार करता है। डिफ़ॉल्ट रूप से, Timeout परमाणु पर सेट है infinity । इसका तात्पर्य यह है कि यदि स्टार्टअप पर Mnesia एक "हैवीवेट लेन-देन" का पता लगाता है जिसका परिणाम स्पष्ट नहीं है, तो स्थानीय Mnesia तब तक प्रतीक्षा करता है जब तक Mnesia अन्य नोड्स के कुछ (सबसे खराब स्थिति में) शुरू हो जाता है जो बाधित लेनदेन में शामिल थे। यह एक दुर्लभ स्थिति है, लेकिन अगर ऐसा होता है, तो मेन्सिया का अनुमान नहीं है कि क्या अन्य नोड्स पर लेनदेन प्रतिबद्ध या समाप्त किया गया था। मानेसिया तब तक इंतजार करता है जब तक कि यह परिणाम नहीं जानता है और फिर उसके अनुसार कार्य करता है।

    यदि Timeout मिलीसेकंड में पूर्णांक मान पर सेट किया जाता है, तो Mnesia "हेवीवेट लेनदेन" को समाप्त करने के लिए मजबूर करता है, भले ही क्षण के लिए लेनदेन का परिणाम स्पष्ट न हो। Timeout मिलीसेकंड के बाद , मानेसिया लेनदेन शुरू करता है या समाप्त करता है और स्टार्टअप के साथ जारी रहता है। यह एक ऐसी स्थिति को जन्म दे सकता है जहां लेनदेन कुछ नोड्स पर प्रतिबद्ध होता है और अन्य नोड्स पर समाप्त हो जाता है। यदि लेन-देन एक स्कीमा लेन-देन है, तो असंगति घातक हो सकती है।

  • -mnesia no_table_loaders NUMBER । शुरुआत के दौरान समानांतर टेबल लोडर की संख्या निर्दिष्ट करता है। अधिक लोडर अच्छा हो सकता है यदि नेटवर्क विलंबता अधिक है या यदि कई तालिकाओं में कुछ रिकॉर्ड हैं। डिफ़ॉल्ट 2

  • -mnesia send_compressed Level । स्थानीय नोड से दूसरे तालिका में प्रतिलिपि बनाते समय उपयोग किए जाने वाले संपीड़न के स्तर को निर्दिष्ट करता है। डिफ़ॉल्ट है 0

    Level अंतराल में एक पूर्णांक होना चाहिए [0, 9] , जहां 0 कोई संपीड़न नहीं है और 9 अधिकतम संपीड़न का मतलब है। इसे गैर-शून्य मान पर सेट करने से पहले, सुनिश्चित करें कि दूरस्थ नोड इस कॉन्फ़िगरेशन को समझते हैं।

  • -mnesia schema_location Loc । नियंत्रण जहां Mnesia अपने स्कीमा की तलाश करता है। पैरामीटर Loc निम्नलिखित परमाणुओं में से एक हो सकता है:

    disc

    अनिवार्य डिस्क। स्कीमा को Mnesia डायरेक्टरी में स्थित माना जाता है। यदि स्कीमा नहीं मिल सकता है, तो मानेसिया शुरू करने से इनकार कर देता है। यह पुराना व्यवहार है।

    ram

    अनिवार्य राम। स्कीमा रैम में ही रहता है। स्टार्टअप पर, एक छोटा नया स्कीमा उत्पन्न होता है। इस डिफ़ॉल्ट स्कीमा में केवल स्कीमा तालिका की परिभाषा है और केवल स्थानीय नोड पर रहता है। चूंकि डिफ़ॉल्ट स्कीमा में कोई अन्य नोड्स नहीं पाए जाते हैं, extra_db_nodes इसलिए नोड को अन्य नोड्स के साथ अपनी टेबल परिभाषाओं को साझा करने के लिए कॉन्फ़िगरेशन पैरामीटर का उपयोग करना चाहिए।

    व्यास का extra_db_nodes उपयोग डिस्क आधारित नोड्स पर भी किया जा सकता है।

    opt_disc

    वैकल्पिक डिस्क। स्कीमा डिस्क पर या रैम में निवास कर सकती है। यदि स्कीमा डिस्क पर पाया जाता है, तो मानेसिया डिस्क-आधारित नोड के रूप में शुरू होता है और स्कीमा तालिका का भंडारण प्रकार है disc_copies । यदि डिस्क पर कोई स्कीमा नहीं पाया जाता है, तो Mnesia डिस्क-कम नोड के रूप में शुरू होता है और स्कीमा तालिका का भंडारण प्रकार होता है ram_copies । आवेदन पैरामीटर के लिए डिफ़ॉल्ट मान है opt_disc

पहले, एसएएसएल एप्लिकेशन मापदंडों की जांच की जाती है, फिर कमांड-लाइन झंडे की जांच की जाती है, और अंत में, डिफ़ॉल्ट मान चुना जाता है।

यह भी देखें

application(3) , dets(3) , disk_log(3) , ets(3) , mnesia_registry(3) , qlc(3)

Original text