ప్రశ్నలను అమలు చేస్తోంది

ప్రకటనలకు పరిచయం

అన్ని SQL ప్రశ్నలను షరతులతో రెండు గ్రూపులుగా విభజించవచ్చు:

• డేటాను తిరిగి పొందడం - వీటిలో SELECT స్టేట్‌మెంట్ ఉంటుంది .
• డేటాను సవరించడం - వీటిలో ఇన్‌సర్ట్ , అప్‌డేట్ మరియు డిలీట్ స్టేట్‌మెంట్‌లు ఉన్నాయి .

మొదటి సమూహం కోసం, ఇప్పటికే మనకు తెలిసిన స్టేట్‌మెంట్ ఇంటర్‌ఫేస్ పద్ధతి ఉపయోగించబడుతుంది - executeQuery() . సూత్రప్రాయంగా, ఈ పద్ధతి ప్రారంభించడానికి చాలా సరిపోతుంది. మీరు నిజమైన ఉద్యోగంలో ఉపయోగించాల్సిన చాలా ఎక్కువ శాతం ప్రశ్నలను ఇది కవర్ చేస్తుంది.

మేము తర్వాత మరిన్ని ఎంపికలను పొందుతాము, కానీ ప్రస్తుతానికి, గుర్తుంచుకోవాలని నేను మీకు సలహా ఇస్తున్నాను - మీరు కేవలం పట్టిక నుండి డేటాను పొందాలనుకుంటే, చాలా సందర్భాలలో executeQuery () పద్ధతి సరైన ఎంపికగా ఉంటుంది.

రెండవ సమూహ అభ్యర్థనల కోసం, మీరు స్టేట్‌మెంట్ ఇంటర్‌ఫేస్ యొక్క మరొక పద్ధతిని ఉపయోగించాలి - executeUpdate() . ExecuteQuery() పద్ధతి వలె కాకుండా , ఇది ResultSetని అందిస్తుంది, ఈ పద్ధతి మీ ప్రశ్నను అమలు చేసినప్పుడు పట్టికలో ఎన్ని అడ్డు వరుసలు మార్చబడిందో తెలిపే పూర్ణాంకాన్ని అందిస్తుంది .

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

సూత్రప్రాయంగా, మేము ఈ ప్రశ్నను పూర్తి చేయవచ్చు - మేము ఇప్పటికే ప్రధాన విషయం చూశాము. డేటా పొందడం కోసం - executeQuery() . డేటాను మార్చడానికి - executeUpdate() .

executeQuery() పద్ధతిని ఉపయోగించి వినియోగదారు పట్టికలో వినియోగదారుల సంఖ్యను పొందండి :

	ResultSet results = statement.executeQuery("SELECT Count(*) FROM user");
	results.next();
    int count = results.getInt(1);

executeUpdate()

మీ ప్రశ్న పట్టికలో ఏదైనా మారినప్పుడు executeUpdate() పద్ధతి ఉపయోగించబడుతుంది. ఇది ఏదైనా కావచ్చు:

• ప్రకటనను నవీకరించండి
• ప్రకటనను చొప్పించండి
• ప్రకటనను తొలగించు
• కాల్ ప్రొసీజర్ స్టేట్‌మెంట్

ఈ పద్ధతి మార్చబడిన (లేదా తొలగించబడిన) వరుసల సంఖ్యను అందిస్తుంది.

మా ఉద్యోగులందరి జీతం 1000 రూబిళ్లు పెంచే అభ్యర్థనను వ్రాస్దాం.

   int rowsCount = statement.executeUpdate("UPDATE  employee SET salary = salary+1000");

నేను ఈ కోడ్‌ని అమలు చేసిన తర్వాత, అది నా టేబుల్‌పై 6 నంబర్‌ని తిరిగి ఇచ్చింది. నా టేబుల్‌కి 6 అడ్డు వరుసలు ఉన్నాయి. కాబట్టి అన్ని లైన్లు మార్చబడ్డాయి.

అమలు ()

మీరు ఏ అభ్యర్థనను అమలు చేయాలో ఖచ్చితంగా తెలియనప్పుడు కొన్నిసార్లు మీ జీవితంలో పరిస్థితులు తలెత్తవచ్చు - ఎంపిక లేదా డేటా మార్పు. ఈ సందర్భంలో, JDBC యొక్క సృష్టికర్తలు దానికి మరొక సాధారణ పద్ధతిని జోడించారు - ఎగ్జిక్యూట్() .

ఈ పద్ధతిని executeQuery() మరియు executeUpdate() పద్ధతుల స్థానంలో ఉపయోగించవచ్చు . ఈ పద్ధతులు ఎలా విభిన్నంగా ఉన్నాయో మీకు గుర్తుందా? కుడి. ఫలితం రకం. అందువల్ల, JDBC సృష్టికర్తలు అలాంటి పరిష్కారంతో ముందుకు వచ్చారు.

ఎగ్జిక్యూట్() పద్ధతి బూలియన్‌ని అందిస్తుంది. ఈ విలువ నిజమైతే , డేటా పొందడం అభ్యర్థన ప్రోగ్రెస్‌లో ఉంది మరియు డేటాను పొందడానికి మీరు getResultSet() పద్ధతికి కాల్ చేయాలి. ఉదాహరణ:

    boolean hasResults = statement.execute("SELECT Count(*) FROM user");
    if ( hasResults ) {
        	ResultSet results =  statement.getResultSet();
        	results.next();
        	int count = results.getInt(1);
 	}

ఈ విలువ తప్పు అయితే , డేటా మార్పు అభ్యర్థన ప్రోగ్రెస్‌లో ఉంది మరియు అడ్డు వరుసల సంఖ్యను మార్చడానికి మీరు getUpdateCount() పద్ధతికి కాల్ చేయాలి. ఉదాహరణ:

    boolean hasResults = statement.execute("UPDATE  employee SET salary = salary+1000");
    if ( !hasResults ) {
      	int count = statement.getUpdateCount();
 	}

ప్రశ్న యొక్క ఫలితాన్ని ప్రదర్శించే పద్ధతిని వ్రాద్దాం:

	public void executeAndPrintSQLQuery(String sqlQuery) {
 
        boolean hasResults = statement.execute(sqlQuery);
        if ( hasResults ) {
 	          ResultSet results =  statement.getResultSet();
           	System.out.println(“Your request lines below: ”);
 
           	while (results.next()) {
 	                 Integer id = results.getInt(1);
     	             String name = results.getString(2);
                      System.out.println(results.getRow() + ". " + id + "\t"+ name);
  	        }
       }
 	  else {
            int count = statement.getUpdateCount();
        	System.out.println(“Number of name strings: ” + count);
  	}
}

ఈ విధంగా అమలులో () పద్ధతి సాధారణంగా ఆచరణలో ఉపయోగించబడుతుంది.