డేటాబేస్తో పని చేస్తున్నప్పుడు లావాదేవీలు

లావాదేవీలు ఎందుకు అవసరం

చాలా తరచుగా, డేటాబేస్తో పని చేస్తున్నప్పుడు, మీరు అనేక విభిన్న చర్యలను చేయవలసి వచ్చినప్పుడు పరిస్థితి తలెత్తుతుంది, కానీ అవి కలిసి మాత్రమే అర్ధవంతంగా ఉంటాయి.

ఉదాహరణకు, మేము మూడు పనులు చేయాల్సిన బ్యాంకింగ్ సాఫ్ట్‌వేర్‌ను వ్రాస్తున్నాము:

• కస్టమర్ ఖాతా నుండి డబ్బును విత్‌డ్రా చేయండి
• గ్రహీత ఖాతాకు డబ్బును జోడించండి
• పోస్టింగ్ డేటాను "పోస్టింగ్ లాగ్"లో రికార్డ్ చేయండి

ఈ చర్యలలో ఏదైనా అమలు సమయంలో లోపం సంభవించినట్లయితే, మిగిలిన రెండింటిని కూడా రద్దు చేయాలి. క్లయింట్ నుండి డబ్బు రాయడం అసాధ్యం మరియు దానిని గ్రహీతకు జోడించలేదా? బాగా, లేదా గ్రహీతకు జోడించు, కానీ క్లయింట్ నుండి వ్రాయలేదా?

కాబట్టి, వివిధ చర్యల యొక్క తార్కిక సమూహాన్ని ఒక లావాదేవీ అంటారు . మరో మాటలో చెప్పాలంటే, లావాదేవీ అనేది అన్నీ కలిసి మాత్రమే నిర్వహించాల్సిన చర్యల సమూహం . ఏదైనా చర్య విఫలమైతే లేదా లోపంతో అమలు చేయబడినట్లయితే, అన్ని ఇతర చర్యలు తప్పనిసరిగా రద్దు చేయబడాలి.

లావాదేవీ సాధారణంగా మూడు రాష్ట్రాలను కలిగి ఉంటుంది:

• ప్రారంభ స్థితి - చర్యల సమూహాన్ని అమలు చేయడానికి ముందు సిస్టమ్ యొక్క స్థితి
• విజయ స్థితి - చర్య సమూహం పూర్తయిన తర్వాత స్థితి
• విఫలమైన స్థితి - ఏదో తప్పు జరిగింది

ఈ సందర్భంలో, సాధారణంగా మూడు ఆదేశాలు ఉన్నాయి:

• ప్రారంభం/ప్రారంభం - తార్కిక సమూహ చర్యల ప్రారంభానికి ముందు అమలు చేయబడుతుంది
• కమిట్ - లావాదేవీ చర్య సమూహం తర్వాత అమలు చేయబడుతుంది
• రోల్‌బ్యాక్ - సిస్టమ్‌ను విఫలమైన స్థితి నుండి ప్రారంభ స్థితికి తిరిగి ఇచ్చే ప్రక్రియను ప్రారంభిస్తుంది

ఇది ఇలా పనిచేస్తుంది.

ముందుగా మీరు లావాదేవీని తెరవాలి - ప్రారంభం() లేదా స్టార్ట్() పద్ధతికి కాల్ చేయండి . ఈ పద్ధతిని పిలవడం ఏదైనా తప్పు జరిగితే మనం తిరిగి రావడానికి ప్రయత్నించే సిస్టమ్ స్థితిని సూచిస్తుంది.

అప్పుడు అన్ని చర్యలు నిర్వహించబడతాయి, ఇవి తార్కిక సమూహంగా మిళితం చేయబడతాయి - ఒక లావాదేవీ.

అప్పుడు కమిట్ () పద్ధతిని అంటారు . దీని కాల్ తార్కిక సమూహ చర్యల ముగింపును సూచిస్తుంది మరియు సాధారణంగా ఈ చర్యలను ఆచరణలో పెట్టే ప్రక్రియను కూడా ప్రారంభిస్తుంది.

ఫైల్‌రైటర్‌లో మనం ఏదైనా ఎలా వ్రాసామో గుర్తుచేసుకోండి: మొదట, మేము వ్రాసిన ప్రతిదీ మెమరీలో నిల్వ చేయబడుతుంది, ఆపై ఫ్లష్ () పద్ధతిని పిలిచినప్పుడు , మెమరీలోని బఫర్ నుండి మొత్తం డేటా డిస్క్‌కు వ్రాయబడుతుంది. ఈ ఫ్లష్() అనేది లావాదేవీ నిబద్ధత.

బాగా, లావాదేవీ యొక్క ఆపరేషన్ సమయంలో లోపం సంభవించినట్లయితే, మీరు ప్రారంభ స్థితికి తిరిగి వచ్చే ప్రక్రియను ప్రారంభించాలి. ఈ ప్రక్రియను రోల్‌బ్యాక్() అని పిలుస్తారు మరియు అదే పేరుతో ఉన్న పద్ధతి సాధారణంగా దీనికి బాధ్యత వహిస్తుంది.

స్థూలంగా చెప్పాలంటే, లావాదేవీని పూర్తి చేయడానికి 2 మార్గాలు ఉన్నాయి:

• COMMIT - మేము చేసిన అన్ని మార్పులను నిర్ధారిస్తాము
• ROLLBACK - చేసిన అన్ని మార్పులను వెనక్కి తీసుకోండి

JDBCలో లావాదేవీలు

దాదాపు ప్రతి DBMS లావాదేవీలతో పని చేయగలదు. కాబట్టి ఈ కేసుకు జెడిబిసి కూడా మద్దతు ఇస్తుంది. ప్రతిదీ చాలా సరళంగా అమలు చేయబడుతుంది.

మొదట, స్టేట్‌మెంట్ ఆబ్జెక్ట్ యొక్క ఎగ్జిక్యూట్() పద్ధతికి ప్రతి కాల్ ప్రత్యేక లావాదేవీలో అమలు చేయబడుతుంది. దీన్ని చేయడానికి, కనెక్షన్ ఆటోకమిట్ పరామితిని కలిగి ఉంటుంది . ఇది ఒప్పుకు సెట్ చేయబడితే , ఎగ్జిక్యూట్() పద్ధతికి ప్రతి కాల్ తర్వాత కమిట్() కాల్ చేయబడుతుంది .

రెండవది, మీరు ఒక లావాదేవీలో అనేక ఆదేశాలను అమలు చేయాలనుకుంటే, మీరు దీన్ని ఇలా చేయవచ్చు:

• ఆటోకమిట్‌ని నిలిపివేయండి
• మా ఆదేశాలను పిలుస్తోంది
• కమిట్() పద్ధతిని స్పష్టంగా కాల్ చేయండి

ఇది చాలా సరళంగా కనిపిస్తుంది:

connection.setAutoCommit(false);

Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
int rowsCount3 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");

connection.commit();

కమిట్() పద్ధతి నడుస్తున్నప్పుడు సర్వర్‌లో లోపం సంభవించినట్లయితే , SQL సర్వర్ మూడు చర్యలను రద్దు చేస్తుంది.

కానీ క్లయింట్ వైపు లోపం ఇప్పటికీ సంభవించే పరిస్థితులు ఉన్నాయి మరియు మేము కమిట్() పద్ధతి కాల్‌కు ఎప్పుడూ రాలేదు :

connection.setAutoCommit(false);

Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");

connection.commit();

ఒక executeUpdate() అమలు సమయంలో లోపం సంభవించినట్లయితే , అప్పుడు కమిట్() పద్ధతిని పిలవబడదు. తీసుకున్న అన్ని చర్యలను వెనక్కి తీసుకోవడానికి, మీరు రోల్‌బ్యాక్() పద్ధతికి కాల్ చేయాలి . ఇది సాధారణంగా ఇలా కనిపిస్తుంది:

try{
  	connection.setAutoCommit(false);

  	Statement statement = connection.createStatement();
  	int rowsCount1 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
  	int rowsCount2 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
  	int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");

	  connection.commit();
 }
 catch (Exception e) {
   connection.rollback();
}

సేవ్ పాయింట్లు

JDBC 3.0 రావడంతో, లావాదేవీల రోల్‌బ్యాక్‌తో మరింత సమర్థవంతంగా పని చేయడం సాధ్యమైంది. ఇప్పుడు మీరు సేవ్ పాయింట్లను సెట్ చేయవచ్చు - పాయింట్లను సేవ్ చేయండి మరియు మీరు రోల్‌బ్యాక్ () ఆపరేషన్‌కు కాల్ చేసినప్పుడు , నిర్దిష్ట సేవ్ పాయింట్‌కి తిరిగి వెళ్లండి.

సేవ్ చేయడానికి, మీరు సేవ్ పాయింట్‌ని సృష్టించాలి, ఇది ఆదేశంతో చేయబడుతుంది:

Savepoint save = connection.setSavepoint();

సేవ్‌పాయింట్‌కి తిరిగి వెళ్లడం ఆదేశంతో చేయబడుతుంది:

connection.rollback(save);

మన సమస్యాత్మక కమాండ్‌కు ముందు సేవ్ పాయింట్‌ని జోడించడాన్ని ప్రయత్నిద్దాం:

try{
  	connection.setAutoCommit(false);

  	Statement statement = connection.createStatement();
  	int rowsCount1 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");
  	int rowsCount2 = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");

  	Savepoint save = connection.setSavepoint();
 	 try{
      	int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");
 	 }
 	 catch (Exception e) {
    	   connection.rollback(save);
 	 }

	  connection.commit();
 }
 catch (Exception e) {
   connection.rollback();
}

మేము సమస్యాత్మక పద్ధతికి కాల్ చేయడానికి ముందు సేవ్-పాయింట్‌ని జోడించడం ద్వారా సమూహ లావాదేవీలను నిర్వహించాము మరియు రోల్‌బ్యాక్(సేవ్) పద్ధతికి కాల్ చేయడం ద్వారా సేవ్ చేసిన స్థితికి తిరిగి వచ్చాము .

అవును, గేమ్‌లలో సేవ్/లోడ్ చేయడానికి ఇది చాలా పోలి ఉంటుంది.