Course All lectures for TA purposes - Lecture: தரவுத்தளத்துடன் பணிபுரியும் போது பரிவர்த்தனைகள்

ஏன் பரிவர்த்தனைகள் தேவை

பெரும்பாலும், ஒரு தரவுத்தளத்துடன் பணிபுரியும் போது, நீங்கள் பலவிதமான செயல்களைச் செய்ய வேண்டியிருக்கும் போது ஒரு சூழ்நிலை எழுகிறது, ஆனால் அவை ஒன்றாக மட்டுமே அர்த்தமுள்ளதாக இருக்கும்.

எடுத்துக்காட்டாக, நாங்கள் மூன்று விஷயங்களைச் செய்ய வேண்டிய வங்கி மென்பொருளை எழுதுகிறோம்:

வாடிக்கையாளரின் கணக்கிலிருந்து பணத்தை எடுக்கவும்
பெறுநரின் கணக்கில் பணத்தைச் சேர்க்கவும்
இடுகையிடும் தரவை "இடுகைப் பதிவில்" பதிவு செய்யவும்

இந்த செயல்களில் ஏதேனும் ஒன்றைச் செயல்படுத்தும்போது பிழை ஏற்பட்டால், மற்ற இரண்டையும் ரத்து செய்ய வேண்டும். வாடிக்கையாளரிடமிருந்து பணத்தை எழுதி, பெறுநரிடம் சேர்க்காமல் இருப்பது சாத்தியமில்லையா? சரி, அல்லது பெறுநரிடம் சேர்க்கவும், ஆனால் வாடிக்கையாளரிடமிருந்து எழுதவில்லையா?

எனவே, வெவ்வேறு செயல்களின் ஒரு தர்க்கரீதியான குழுவாக ஒரு பரிவர்த்தனை என்று அழைக்கப்படுகிறது . வேறு வார்த்தைகளில் கூறுவதானால், பரிவர்த்தனை என்பது அனைத்தும் ஒன்றாக மட்டுமே செய்யப்பட வேண்டிய செயல்களின் குழுவாகும் . எந்தவொரு செயலும் தோல்வியுற்றாலோ அல்லது பிழையுடன் செயல்படுத்தப்பட்டாலோ, மற்ற எல்லா செயல்களும் ரத்து செய்யப்பட வேண்டும்.

ஒரு பரிவர்த்தனை பொதுவாக மூன்று மாநிலங்களைக் கொண்டுள்ளது:

ஆரம்ப நிலை - செயல்களின் குழுவைச் செயல்படுத்துவதற்கு முன் அமைப்பின் நிலை
வெற்றி நிலை - செயல் குழு முடிந்ததும் நிலை
தோல்வியடைந்த நிலை - ஏதோ தவறாகிவிட்டது

இந்த வழக்கில், பொதுவாக மூன்று கட்டளைகள் உள்ளன:

ஆரம்பம்/தொடக்கம் - தர்க்கரீதியான செயல்களின் தொடக்கத்திற்கு முன் செயல்படுத்தப்பட்டது
உறுதி - பரிவர்த்தனை நடவடிக்கை குழுவிற்குப் பிறகு செயல்படுத்தப்பட்டது
ரோல்பேக் - தோல்வியடைந்த நிலையில் இருந்து ஆரம்ப நிலைக்கு கணினியை திரும்பப் பெறும் செயல்முறையைத் தொடங்குகிறது

இது இப்படி வேலை செய்கிறது.

முதலில் நீங்கள் ஒரு பரிவர்த்தனையைத் திறக்க வேண்டும் - தொடக்க () அல்லது தொடக்க () முறையை அழைக்கவும் . இந்த முறையை அழைப்பது, ஏதேனும் தவறு நடந்தால் நாம் திரும்ப முயற்சிக்கும் அமைப்பின் நிலையைக் குறிக்கிறது.

பின்னர் அனைத்து செயல்களும் செய்யப்படுகின்றன, அவை ஒரு தருக்க குழுவாக இணைக்கப்படுகின்றன - ஒரு பரிவர்த்தனை.

பின்னர் உறுதி() முறை அழைக்கப்படுகிறது . அதன் அழைப்பு ஒரு தர்க்கரீதியான செயல்களின் முடிவைக் குறிக்கிறது, மேலும் வழக்கமாக இந்த செயல்களை நடைமுறையில் வைக்கும் செயல்முறையைத் தொடங்குகிறது.

FileWriter இல் எதையாவது எப்படி எழுதினோம் என்பதை நினைவுகூருங்கள்: முதலில், நாம் எழுதிய அனைத்தும் நினைவகத்தில் சேமிக்கப்படும், பின்னர் flush () முறை என அழைக்கப்படும் போது , நினைவகத்தில் உள்ள இடையகத்திலிருந்து அனைத்து தரவுகளும் வட்டில் எழுதப்படும். இந்த பறிப்பு() என்பது பரிவர்த்தனை உறுதி.

சரி, பரிவர்த்தனையின் செயல்பாட்டின் போது பிழை ஏற்பட்டால், நீங்கள் தொடக்க நிலைக்குத் திரும்புவதற்கான செயல்முறையைத் தொடங்க வேண்டும். இந்த செயல்முறை ரோல்பேக்() என்று அழைக்கப்படுகிறது , மேலும் அதே பெயரின் முறையே இதற்குப் பொறுப்பாகும்.

தோராயமாகச் சொன்னால், பரிவர்த்தனையை முடிக்க 2 வழிகள் உள்ளன:

COMMIT - செய்யப்பட்ட அனைத்து மாற்றங்களையும் நாங்கள் உறுதிப்படுத்துகிறோம்
பின்னடைவு - செய்யப்பட்ட அனைத்து மாற்றங்களையும் திரும்பப் பெறவும்

JDBC இல் பரிவர்த்தனைகள்

கிட்டத்தட்ட ஒவ்வொரு டிபிஎம்எஸ்ஸும் பரிவர்த்தனைகளுடன் வேலை செய்ய முடியும். எனவே இந்த வழக்குக்கு ஜேடிபிசியும் ஆதரவு தெரிவித்துள்ளது. எல்லாம் மிகவும் எளிமையாக செயல்படுத்தப்படுகிறது.

முதலில், ஸ்டேட்மென்ட் ஆப்ஜெக்ட்டின் execute() முறைக்கான ஒவ்வொரு அழைப்பும் ஒரு தனி பரிவர்த்தனையில் செயல்படுத்தப்படுகிறது. இதைச் செய்ய, இணைப்பில் ஒரு ஆட்டோகமிட் அளவுரு உள்ளது . இது true என அமைக்கப்பட்டால் , execute() முறைக்கு ஒவ்வொரு அழைப்புக்குப் பிறகும் commit() அழைக்கப்படும் .

இரண்டாவதாக, நீங்கள் ஒரு பரிவர்த்தனையில் பல கட்டளைகளை இயக்க விரும்பினால், நீங்கள் அதை இப்படி செய்யலாம்:

ஆட்டோகமிட்டை முடக்கு
எங்கள் கட்டளைகளை அழைக்கிறது
உறுதி() முறையை வெளிப்படையாக அழைக்கவும்

இது மிகவும் எளிமையானதாக தோன்றுகிறது:

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();
}

சேமிப்பு புள்ளிகள்

ஜேடிபிசி 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();
}

பிரச்சனைக்குரிய முறையை அழைப்பதற்கு முன் ஒரு சேவ்-பாயிண்ட்டைச் சேர்ப்பதன் மூலம் உள்ளமை பரிவர்த்தனைகளை நாங்கள் ஒழுங்கமைத்துள்ளோம் , மேலும் ரோல்பேக்(சேவ்) முறையை அழைப்பதன் மூலம் சேமித்த நிலைக்குத் திரும்புகிறோம் .

ஆம், கேம்களில் சேமிக்க/ஏற்றுவதற்கு இது மிகவும் ஒத்ததாகும்.