ఇంటర్‌సిస్టమ్స్ IRIS DBMS డేటాను నిల్వ చేయడానికి ఆసక్తికరమైన నిర్మాణాలకు మద్దతు ఇస్తుంది - గ్లోబల్స్. ముఖ్యంగా, ఇవి లావాదేవీల రూపంలో వివిధ అదనపు గూడీస్‌తో కూడిన బహుళ-స్థాయి కీలు, డేటా ట్రీలను దాటడానికి వేగవంతమైన విధులు, లాక్‌లు మరియు దాని స్వంత ఆబ్జెక్ట్‌స్క్రిప్ట్ భాష.
“గ్లోబల్‌లు డేటాను నిల్వ చేయడానికి నిధి-కత్తులు” కథనాల శ్రేణిలో గ్లోబల్‌ల గురించి మరింత చదవండి:
గ్లోబల్స్‌లో లావాదేవీలు ఎలా అమలు చేయబడతాయి, ఏ ఫీచర్లు ఉన్నాయి అనే విషయాలపై నాకు ఆసక్తి పెరిగింది. అన్నింటికంటే, ఇది సాధారణ పట్టికల కంటే డేటాను నిల్వ చేయడానికి పూర్తిగా భిన్నమైన నిర్మాణం. చాలా తక్కువ స్థాయి.
రిలేషనల్ డేటాబేస్ సిద్ధాంతం నుండి తెలిసినట్లుగా, లావాదేవీల యొక్క మంచి అమలు అవసరాలను తీర్చాలి :
A - పరమాణు (పరమాణువు). లావాదేవీలో చేసిన అన్ని మార్పులు లేదా ఏవీ రికార్డ్ చేయబడవు.
సి - స్థిరత్వం. లావాదేవీ పూర్తయిన తర్వాత, డేటాబేస్ యొక్క తార్కిక స్థితి తప్పనిసరిగా అంతర్గతంగా స్థిరంగా ఉండాలి. అనేక విధాలుగా ఈ అవసరం ప్రోగ్రామర్‌కు సంబంధించినది, కానీ SQL డేటాబేస్‌ల విషయంలో ఇది విదేశీ కీలకు కూడా సంబంధించినది.
నేను - ఐసోలేట్. సమాంతరంగా నడుస్తున్న లావాదేవీలు ఒకదానికొకటి ప్రభావితం కాకూడదు.
D - మన్నికైనది. లావాదేవీని విజయవంతంగా పూర్తి చేసిన తర్వాత, దిగువ స్థాయిలలో సమస్యలు (విద్యుత్ వైఫల్యం, ఉదాహరణకు) లావాదేవీ ద్వారా మార్చబడిన డేటాను ప్రభావితం చేయకూడదు.
గ్లోబల్స్ నాన్-రిలేషనల్ డేటా స్ట్రక్చర్‌లు. అవి చాలా పరిమిత హార్డ్‌వేర్‌తో సూపర్ ఫాస్ట్‌గా పనిచేసేలా రూపొందించబడ్డాయి. ఉపయోగించి గ్లోబల్స్‌లో లావాదేవీల అమలును చూద్దాం .
IRISలో లావాదేవీలకు మద్దతు ఇవ్వడానికి, కింది ఆదేశాలు ఉపయోగించబడతాయి: , , .
1. పరమాణువు
తనిఖీ చేయడానికి సులభమైన మార్గం అటామిసిటీ. మేము డేటాబేస్ కన్సోల్ నుండి తనిఖీ చేస్తాము.
Kill ^a
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TCOMMITఅప్పుడు మేము ముగిస్తాము:
Write ^a(1), “ ”, ^a(2), “ ”, ^a(3)మాకు దొరికింది:
1 2 3అంతా బాగానే ఉంది. అటామిసిటీ నిర్వహించబడుతుంది: అన్ని మార్పులు నమోదు చేయబడతాయి.
పనిని క్లిష్టతరం చేద్దాం, లోపాన్ని పరిచయం చేద్దాం మరియు లావాదేవీ ఎలా సేవ్ చేయబడిందో చూద్దాం, పాక్షికంగా లేదా అస్సలు కాదు.
అణుశక్తిని మళ్లీ తనిఖీ చేద్దాం:
Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3అప్పుడు మేము కంటైనర్‌ను బలవంతంగా ఆపి, దానిని ప్రారంభించి చూస్తాము.
docker kill my-irisఈ కమాండ్ దాదాపుగా ఫోర్స్ షట్‌డౌన్‌కి సమానం, ఎందుకంటే ఇది ప్రక్రియను వెంటనే ఆపడానికి SIGKILL సిగ్నల్‌ను పంపుతుంది.
బహుశా లావాదేవీ పాక్షికంగా సేవ్ చేయబడిందా?
WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)- లేదు, అది మనుగడ సాగించలేదు.
రోల్‌బ్యాక్ ఆదేశాన్ని ప్రయత్నిద్దాం:
Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TROLLBACK
WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)ఏదీ కూడా బయటపడలేదు.
2. స్థిరత్వం
గ్లోబల్స్ ఆధారంగా డేటాబేస్‌లలో, గ్లోబల్స్‌లో కూడా కీలు తయారు చేయబడతాయి (రిలేషనల్ టేబుల్ కంటే డేటాను నిల్వ చేయడానికి గ్లోబల్ అనేది తక్కువ-స్థాయి నిర్మాణం అని నేను మీకు గుర్తు చేస్తాను), స్థిరత్వ అవసరాన్ని తీర్చడానికి, కీలో మార్పు తప్పనిసరిగా చేర్చబడాలి అదే లావాదేవీలో గ్లోబల్‌లో మార్పు.
ఉదాహరణకు, మేము గ్లోబల్ ^వ్యక్తిని కలిగి ఉన్నాము, దీనిలో మేము వ్యక్తిత్వాలను నిల్వ చేస్తాము మరియు మేము TINని కీగా ఉపయోగిస్తాము.
^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
...చివరి పేరు మరియు మొదటి పేరు ద్వారా శీఘ్ర శోధనను కలిగి ఉండటానికి, మేము ^ఇండెక్స్ కీని తయారు చేసాము.
^index(‘Kamenev’, ‘Sergey’, 1234567) = 1డేటాబేస్ స్థిరంగా ఉండాలంటే, మనం తప్పనిసరిగా ఇలా వ్యక్తిత్వాన్ని జోడించాలి:
TSTART
^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
^index(‘Kamenev’, ‘Sergey’, 1234567) = 1
TCOMMITదీని ప్రకారం, తొలగించేటప్పుడు మనం తప్పనిసరిగా లావాదేవీని కూడా ఉపయోగించాలి:
TSTART
Kill ^person(1234567)
ZKill ^index(‘Kamenev’, ‘Sergey’, 1234567)
TCOMMITమరో మాటలో చెప్పాలంటే, స్థిరత్వ అవసరాన్ని నెరవేర్చడం పూర్తిగా ప్రోగ్రామర్ భుజాలపై ఆధారపడి ఉంటుంది. కానీ గ్లోబల్స్ విషయానికి వస్తే, వారి తక్కువ-స్థాయి స్వభావం కారణంగా ఇది సాధారణం.
3. ఐసోలేషన్
ఇక్కడే అడవి మొదలవుతుంది. చాలా మంది వినియోగదారులు ఒకే డేటాబేస్‌లో ఏకకాలంలో పని చేస్తారు, అదే డేటాను మారుస్తారు.
చాలా మంది వినియోగదారులు ఒకే కోడ్ రిపోజిటరీతో ఏకకాలంలో పనిచేసినప్పుడు మరియు ఒకేసారి అనేక ఫైల్‌లకు ఒకేసారి మార్పులు చేయడానికి ప్రయత్నించినప్పుడు పరిస్థితి పోల్చవచ్చు.
డేటాబేస్ నిజ సమయంలో అన్నింటినీ క్రమబద్ధీకరించాలి. తీవ్రమైన కంపెనీలలో సంస్కరణ నియంత్రణకు (శాఖలను విలీనం చేయడం, వైరుధ్యాలను పరిష్కరించడం మొదలైనవి) బాధ్యత వహించే ప్రత్యేక వ్యక్తి కూడా ఉన్నారని పరిగణనలోకి తీసుకుంటే, మరియు డేటాబేస్ ఇవన్నీ నిజ సమయంలో చేయాలి, పని యొక్క సంక్లిష్టత మరియు ఖచ్చితత్వం డేటాబేస్ రూపకల్పన మరియు దానిని అందించే కోడ్.
వినియోగదారులు ఒకే డేటాపై పని చేస్తున్నట్లయితే వైరుధ్యాలను నివారించడానికి వారు చేసే చర్యల అర్థాన్ని డేటాబేస్ అర్థం చేసుకోలేదు. ఇది మరొక లావాదేవీతో విభేదించే ఒక లావాదేవీని మాత్రమే రద్దు చేయగలదు లేదా వాటిని వరుసగా అమలు చేయగలదు.
మరొక సమస్య ఏమిటంటే, లావాదేవీని అమలు చేసే సమయంలో (కమిట్ అయ్యే ముందు), డేటాబేస్ యొక్క స్థితి అస్థిరంగా ఉండవచ్చు, కాబట్టి ఇతర లావాదేవీలు డేటాబేస్ యొక్క అస్థిర స్థితికి ప్రాప్యతను కలిగి ఉండకపోవడమే మంచిది, ఇది రిలేషనల్ డేటాబేస్‌లలో సాధించబడుతుంది. అనేక విధాలుగా: స్నాప్‌షాట్‌లను సృష్టించడం, బహుళ-వెర్షనింగ్ వరుసలు మరియు మొదలైనవి.
లావాదేవీలను సమాంతరంగా అమలు చేస్తున్నప్పుడు, అవి ఒకదానితో ఒకటి జోక్యం చేసుకోకుండా ఉండటం మాకు ముఖ్యం. ఇది ఒంటరితనం యొక్క ఆస్తి.
SQL 4 ఐసోలేషన్ స్థాయిలను నిర్వచిస్తుంది:
- నిబద్ధత లేని చదువు
- నిబద్ధతతో చదవండి
- పునరావృత పఠనం
- క్రమీకరించదగినది
ప్రతి స్థాయిని విడిగా చూద్దాం. ప్రతి స్థాయిని అమలు చేయడానికి అయ్యే ఖర్చులు దాదాపుగా విపరీతంగా పెరుగుతాయి.
నిబద్ధత లేని చదువు - ఇది ఐసోలేషన్ యొక్క అత్యల్ప స్థాయి, కానీ అదే సమయంలో వేగవంతమైనది. లావాదేవీలు ఒకదానికొకటి చేసిన మార్పులను చదవగలవు.
నిబద్ధతతో చదవండి అనేది తదుపరి స్థాయి ఒంటరితనం, ఇది రాజీ. లావాదేవీలు కమిట్‌కు ముందు ఒకదానికొకటి మార్పులను చదవలేవు, కానీ అవి కమిట్ అయిన తర్వాత చేసిన ఏవైనా మార్పులను చదవగలవు.
T1 వంటి అదే డేటాతో పనిచేసిన T2, T3 ... Tn లావాదేవీలలో కమిట్‌లు జరిగినప్పుడు T1 సుదీర్ఘ లావాదేవీని కలిగి ఉన్నట్లయితే, T1లో డేటాను అభ్యర్థించినప్పుడు మేము ప్రతిసారీ విభిన్న ఫలితాన్ని పొందుతాము. ఈ దృగ్విషయాన్ని పునరావృతం కాని పఠనం అంటారు.
పునరావృత పఠనం — ఈ ఐసోలేషన్ స్థాయిలో, డేటాను చదవడానికి ప్రతి అభ్యర్థన కోసం, ఫలిత డేటా యొక్క స్నాప్‌షాట్ సృష్టించబడుతుంది మరియు అదే లావాదేవీలో, స్నాప్‌షాట్ నుండి డేటాను మళ్లీ ఉపయోగించినప్పుడు, ఈ ఐసోలేషన్ స్థాయిలో మనకు పునరావృతం కాని రీడింగ్ అనే దృగ్విషయం లేదు. ఉపయోగించబడింది. అయితే, ఈ ఐసోలేషన్ స్థాయిలో ఫాంటమ్ డేటాను చదవడం సాధ్యమవుతుంది. ఇది సమాంతర నిబద్ధత లావాదేవీల ద్వారా జోడించబడిన కొత్త అడ్డు వరుసలను చదవడాన్ని సూచిస్తుంది.
క్రమీకరించదగినది - ఇన్సులేషన్ యొక్క అత్యధిక స్థాయి. లావాదేవీలో (చదవటం లేదా మార్చడం) ఏ విధంగానైనా ఉపయోగించిన డేటా మొదటి లావాదేవీ పూర్తయిన తర్వాత మాత్రమే ఇతర లావాదేవీలకు అందుబాటులోకి వస్తుంది అనే వాస్తవం దీని లక్షణం.
ముందుగా, ప్రధాన థ్రెడ్ నుండి ఒక లావాదేవీలో ఆపరేషన్ల ఐసోలేషన్ ఉందో లేదో తెలుసుకుందాం. 2 టెర్మినల్ విండోలను తెరుద్దాం.
Kill ^t
Write ^t(1)
2
TSTART
Set ^t(1)=2ఒంటరితనం లేదు. లావాదేవీని తెరిచిన రెండవ వ్యక్తి ఏమి చేస్తున్నాడో ఒక థ్రెడ్ చూస్తుంది.
వివిధ థ్రెడ్‌ల లావాదేవీలు వాటి లోపల ఏమి జరుగుతుందో చూద్దాం.
2 టెర్మినల్ విండోలను తెరిచి, 2 లావాదేవీలను సమాంతరంగా తెరుద్దాం.
kill ^t
TSTART
Write ^t(1)
3
TSTART
Set ^t(1)=3
సమాంతర లావాదేవీలు ఒకదానికొకటి డేటాను చూస్తాయి. కాబట్టి, మేము సరళమైన, కానీ వేగవంతమైన ఐసోలేషన్ స్థాయిని పొందాము, UNCOMMITED చదవండి.
సూత్రప్రాయంగా, ఇది గ్లోబల్స్ కోసం ఆశించవచ్చు, దీని కోసం పనితీరు ఎల్లప్పుడూ ప్రాధాన్యతనిస్తుంది.
గ్లోబల్స్‌లో కార్యకలాపాలలో మనకు అధిక స్థాయి ఐసోలేషన్ అవసరమైతే?
ఇక్కడ మీరు ఐసోలేషన్ స్థాయిలు ఎందుకు అవసరం మరియు అవి ఎలా పని చేస్తాయి అనే దాని గురించి ఆలోచించాలి.
అత్యధిక ఐసోలేషన్ స్థాయి, SERIALIZE అంటే, సమాంతరంగా అమలు చేయబడిన లావాదేవీల ఫలితం వాటి వరుస అమలుకు సమానం, ఇది ఘర్షణలు లేకపోవడాన్ని హామీ ఇస్తుంది.
మేము దీన్ని ఆబ్జెక్ట్‌స్క్రిప్ట్‌లోని స్మార్ట్ లాక్‌లను ఉపయోగించి చేయవచ్చు, వీటికి చాలా విభిన్న ఉపయోగాలు ఉన్నాయి: మీరు కమాండ్‌తో రెగ్యులర్, ఇంక్రిమెంటల్, మల్టిపుల్ లాకింగ్ చేయవచ్చు .
దిగువ ఐసోలేషన్ స్థాయిలు డేటాబేస్ వేగాన్ని పెంచడానికి రూపొందించబడిన ట్రేడ్-ఆఫ్‌లు.
లాక్‌లను ఉపయోగించి వివిధ స్థాయిల ఐసోలేషన్‌ను ఎలా సాధించవచ్చో చూద్దాం.
ఈ ఆపరేటర్ డేటాను మార్చడానికి అవసరమైన ప్రత్యేకమైన లాక్‌లను మాత్రమే తీసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది, కానీ భాగస్వామ్య లాక్‌లు అని పిలవబడేవి, వారు రీడింగ్ ప్రాసెస్‌లో ఇతర ప్రక్రియల ద్వారా మార్చకూడని డేటాను చదవవలసి వచ్చినప్పుడు సమాంతరంగా అనేక థ్రెడ్‌లను తీసుకోవచ్చు.
రష్యన్ మరియు ఆంగ్లంలో రెండు-దశల నిరోధించే పద్ధతి గురించి మరింత సమాచారం:
→
→
ఇబ్బంది ఏమిటంటే, లావాదేవీ సమయంలో డేటాబేస్ యొక్క స్థితి అస్థిరంగా ఉండవచ్చు, కానీ ఈ అస్థిరమైన డేటా ఇతర ప్రక్రియలకు కనిపిస్తుంది. దీన్ని ఎలా నివారించాలి?
లాక్‌లను ఉపయోగించి, డేటాబేస్ స్థితి స్థిరంగా ఉండే విజిబిలిటీ విండోలను మేము సృష్టిస్తాము. మరియు అంగీకరించిన రాష్ట్రం యొక్క దృశ్యమానత యొక్క అటువంటి విండోలకు అన్ని యాక్సెస్ లాక్‌ల ద్వారా నియంత్రించబడుతుంది.
ఒకే డేటాలోని షేర్డ్ లాక్‌లు పునర్వినియోగపరచదగినవి-అనేక ప్రక్రియలు వాటిని తీసుకోవచ్చు. ఈ లాక్‌లు ఇతర ప్రక్రియలను డేటాను మార్చకుండా నిరోధిస్తాయి, అనగా. అవి స్థిరమైన డేటాబేస్ స్థితి యొక్క విండోలను రూపొందించడానికి ఉపయోగించబడతాయి.
డేటా మార్పుల కోసం ప్రత్యేకమైన లాక్‌లు ఉపయోగించబడతాయి - అటువంటి లాక్‌ని ఒక ప్రక్రియ మాత్రమే తీసుకోగలదు. ప్రత్యేకమైన లాక్‌ని దీని ద్వారా తీసుకోవచ్చు:
- డేటా ఉచితం అయితే ఏదైనా ప్రక్రియ
- ఈ డేటాపై భాగస్వామ్య లాక్‌ని కలిగి ఉన్న ప్రక్రియ మాత్రమే మరియు ప్రత్యేకమైన లాక్‌ని అభ్యర్థించిన మొదటిది.
దృశ్యమానత విండో ఇరుకైనది, ఇతర ప్రక్రియలు దాని కోసం ఎక్కువ కాలం వేచి ఉండాలి, కానీ దానిలోని డేటాబేస్ యొక్క స్థితి మరింత స్థిరంగా ఉంటుంది.
READ_COMMITTED — ఈ స్థాయి యొక్క సారాంశం ఏమిటంటే, మేము ఇతర థ్రెడ్‌ల నుండి కట్టుబడి ఉన్న డేటాను మాత్రమే చూస్తాము. మరొక లావాదేవీలోని డేటా ఇంకా కట్టుబడి ఉండకపోతే, మేము దాని పాత సంస్కరణను చూస్తాము.
ఇది లాక్ విడుదలయ్యే వరకు వేచి ఉండటానికి బదులుగా పనిని సమాంతరంగా చేయడానికి అనుమతిస్తుంది.
ప్రత్యేక ఉపాయాలు లేకుండా, మేము IRISలో డేటా యొక్క పాత వెర్షన్‌ను చూడలేము, కాబట్టి మేము లాక్‌లతో సరిపెట్టుకోవాలి.
తదనుగుణంగా, స్థిరమైన క్షణాల్లో మాత్రమే డేటాను చదవడానికి అనుమతించడానికి మేము షేర్ చేసిన లాక్‌లను ఉపయోగించాల్సి ఉంటుంది.
ఒకరికొకరు డబ్బును బదిలీ చేసుకునే వినియోగదారు బేస్ ^వ్యక్తిని కలిగి ఉన్నారని అనుకుందాం.
వ్యక్తి 123 నుండి వ్యక్తి 242కి బదిలీ చేయబడిన క్షణం:
LOCK +^person(123), +^person(242)
Set ^person(123, amount) = ^person(123, amount) - amount
Set ^person(242, amount) = ^person(242, amount) + amount
LOCK -^person(123), -^person(242)డెబిట్ చేయడానికి ముందు వ్యక్తి 123 నుండి డబ్బు మొత్తాన్ని అభ్యర్థించే క్షణం తప్పనిసరిగా ప్రత్యేకమైన బ్లాక్‌తో పాటు ఉండాలి (డిఫాల్ట్‌గా):
LOCK +^person(123)
Write ^person(123)మరియు మీరు మీ వ్యక్తిగత ఖాతాలో ఖాతా స్థితిని చూపించాల్సిన అవసరం ఉంటే, మీరు షేర్ చేసిన లాక్‌ని ఉపయోగించవచ్చు లేదా దాన్ని అస్సలు ఉపయోగించకూడదు:
LOCK +^person(123)#”S”
Write ^person(123)అయినప్పటికీ, డేటాబేస్ కార్యకలాపాలు దాదాపు తక్షణమే నిర్వహించబడతాయని మేము ఊహిస్తే (గ్లోబల్స్ రిలేషనల్ టేబుల్ కంటే చాలా తక్కువ-స్థాయి నిర్మాణం అని నేను మీకు గుర్తు చేస్తాను), అప్పుడు ఈ స్థాయి అవసరం తగ్గుతుంది.
పునరావృత పఠనం - ఈ ఐసోలేషన్ స్థాయి ఏకకాల లావాదేవీల ద్వారా సవరించబడే డేటా యొక్క బహుళ రీడ్‌లను అనుమతిస్తుంది.
దీని ప్రకారం, మనం మార్చే డేటాను చదవడానికి షేర్డ్ లాక్ మరియు మనం మార్చే డేటాపై ప్రత్యేకమైన లాక్‌లను ఉంచాలి.
అదృష్టవశాత్తూ, LOCK ఆపరేటర్ మీకు అవసరమైన అన్ని లాక్‌లను వివరంగా జాబితా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, వీటిలో చాలా ఉండవచ్చు, ఒక ప్రకటనలో.
LOCK +^person(123, amount)#”S”
чтение ^person(123, amount)ఇతర కార్యకలాపాలు (ఈ సమయంలో సమాంతర థ్రెడ్‌లు ^వ్యక్తిని (123, మొత్తం) మార్చడానికి ప్రయత్నిస్తాయి, కానీ చేయలేవు)
LOCK +^person(123, amount)
изменение ^person(123, amount)
LOCK -^person(123, amount)
чтение ^person(123, amount)
LOCK -^person(123, amount)#”S”కామాలతో వేరు చేయబడిన తాళాలను జాబితా చేస్తున్నప్పుడు, అవి వరుసగా తీసుకోబడతాయి, కానీ మీరు ఇలా చేస్తే:
LOCK +(^person(123),^person(242))అప్పుడు అవి ఒకేసారి పరమాణువుగా తీసుకోబడతాయి.
సీరియలైజ్ — మేము లాక్‌లను సెట్ చేయాల్సి ఉంటుంది, తద్వారా అంతిమంగా సాధారణ డేటా ఉన్న అన్ని లావాదేవీలు వరుసగా అమలు చేయబడతాయి. ఈ విధానం కోసం, చాలా లాక్‌లు ప్రత్యేకమైనవి మరియు పనితీరు కోసం గ్లోబల్‌లోని అతిచిన్న ప్రాంతాలపై తీసుకోవాలి.
మేము గ్లోబల్ ^వ్యక్తిలో నిధులను డెబిట్ చేయడం గురించి మాట్లాడినట్లయితే, సీరియలైజ్ ఐసోలేషన్ స్థాయి మాత్రమే దీనికి ఆమోదయోగ్యమైనది, ఎందుకంటే డబ్బును ఖచ్చితంగా వరుసగా ఖర్చు చేయాలి, లేకుంటే అదే మొత్తాన్ని చాలాసార్లు ఖర్చు చేయడం సాధ్యపడుతుంది.
4. మన్నిక
నేను ఉపయోగించి కంటైనర్ యొక్క హార్డ్ కటింగ్తో పరీక్షలు నిర్వహించాను
docker kill my-irisబేస్ వాటిని బాగా తట్టుకుంది. ఎలాంటి సమస్యలు గుర్తించబడలేదు.
తీర్మానం
గ్లోబల్స్ కోసం, InterSystems IRIS లావాదేవీల మద్దతును కలిగి ఉంది. అవి నిజంగా పరమాణు మరియు నమ్మదగినవి. గ్లోబల్స్ ఆధారంగా డేటాబేస్ యొక్క స్థిరత్వాన్ని నిర్ధారించడానికి, ప్రోగ్రామర్ ప్రయత్నాలు మరియు లావాదేవీల ఉపయోగం అవసరం, ఎందుకంటే ఇది విదేశీ కీల వంటి సంక్లిష్టమైన అంతర్నిర్మిత నిర్మాణాలను కలిగి ఉండదు.
లాక్‌లను ఉపయోగించకుండా గ్లోబల్‌ల యొక్క ఐసోలేషన్ స్థాయి రీడ్ అన్‌కమిటెడ్, మరియు లాక్‌లను ఉపయోగిస్తున్నప్పుడు అది సీరియలైజ్ స్థాయి వరకు ఉండేలా చూసుకోవచ్చు.
గ్లోబల్స్‌లో లావాదేవీల యొక్క ఖచ్చితత్వం మరియు వేగం ప్రోగ్రామర్ యొక్క నైపుణ్యంపై చాలా ఆధారపడి ఉంటుంది: చదివేటప్పుడు విస్తృతంగా భాగస్వామ్యం చేయబడిన తాళాలు ఉపయోగించబడతాయి, ఐసోలేషన్ స్థాయి ఎక్కువగా ఉంటుంది మరియు మరింత ఇరుకైన ప్రత్యేకమైన లాక్‌లు తీసుకుంటే, పనితీరు వేగంగా ఉంటుంది.
మూలం: www.habr.com