ఈరోజు నేను ఒకే డేటాబేస్ ప్యాటర్న్ను మూడుసార్లు గమనించాను
ఈరోజు నా కోడ్లో ఒకే రకమైన డేటాబేస్ నిర్మాణాన్ని మూడుసార్లు చూశాను.
మొదట, నేను దీనిని ఫీజుల (fees) విషయంలో చూశాను.
- Fee (పేరెంట్: ఒక క్లాస్ చెల్లించాల్సిన మొత్తం)
- FeePayment (చైల్డ్: ప్రతి విడి చెల్లింపు)
ఆ తర్వాత, అసెస్మెంట్స్ (assessments) విషయంలో కూడా ఇదే చూశాను.
- Assessment (పేరెంట్: క్విజ్ వివరాలు, తేదీ మరియు గరిష్ట స్కోరు)
- AssessmentResult (చైల్డ్: ప్రతి విద్యార్థి స్కోరు)
ఈ నిర్మాణం సాధారణ తప్పులను నివారిస్తుంది.
మీరు పేరెంట్-చైల్డ్ ప్యాటర్న్ను ఉపయోగించకపోతే, ఈ క్రింది సమస్యలను ఎదుర్కోవాల్సి వస్తుంది:
- మీరు డేటాను మళ్ళీ మళ్ళీ నమోదు చేస్తారు. ప్రతి విద్యార్థి రో (row) కోసం సబ్జెక్ట్ మరియు తేదీని కాపీ చేస్తారు.
- గందరగోళం ఏర్పడుతుంది. ఏ రోలు ఒకే ఈవెంట్కు చెందినవో తెలుసుకోవడం కష్టమవుతుంది.
- టేబుల్స్ నిండిపోతాయి. ఉండాల్సిన చోట కాకుండా, విద్యార్థుల రోలలో హెడర్ డేటాను ఉంచుతారు.
కాలక్రమేణా ప్యాటర్న్లను గుర్తించే సామర్థ్యం పెరుగుతుంది.
మొదటిసారి మీరు ఒక నిర్మాణపరమైన సమస్యను పరిష్కరించినప్పుడు, అది కేవలం ఒక పరిష్కారం మాత్రమే. రెండోసారి మీరు దానిని చూసినప్పుడు, అది ఒక ప్యాటర్న్ అని గుర్తిస్తారు. మూడోసారి, సమస్య ఎదురవ్వకముందే మీరు దానిని ఉపయోగిస్తారు.
నేను ఇంకా ఎడ్జ్ కేస్లను (edge cases) నిర్మిస్తూ మరియు పరీక్షిస్తూనే ఉన్నాను. నేను ఇంకా నేర్చుకుంటూనే ఉన్నాను.