RowSetతో పని చేస్తున్నారు

6.1 RowSet పరిచయం

మీకు ఇప్పటికే తెలిసినట్లుగా, JDBC ప్రమాణం దాదాపు 20 సంవత్సరాల వయస్సు మరియు కొంచెం పాతది. కొత్త రకాలు మరియు కొత్త తరగతులు నెమ్మదిగా జోడించబడుతున్నాయి, కానీ ఇది ప్రతిచోటా అందంగా చేయలేము. మరియు వాటిలో ఒకటి ResultSet .

డేటాబేస్ మరింత సమర్థవంతంగా చేయవచ్చు, కానీ ResultSet ఇంటర్‌ఫేస్ సరిగా సరిపోదు. అదనంగా, మేము దాని వస్తువులను ఎక్కడా స్పష్టంగా సృష్టించము, అవి మాకు తిరిగి ఇవ్వబడతాయి executeQuery().

JDBC సృష్టికర్తలు ఎక్కువసేపు ఆలోచించలేదు మరియు అంతకుముందు ఉన్న ప్రతిదానికీ పూర్తిగా సమాంతరంగా ఉండే యంత్రాంగాన్ని రూపొందించారు. మరియు అది RowSet అని పిలువబడింది .

దాని ప్రధాన ప్రయోజనాలు ఇక్కడ ఉన్నాయి:

• RowSet ResultSet ఇంటర్‌ఫేస్‌ను విస్తరించింది, కాబట్టి దాని విధులు ResultSet కంటే శక్తివంతమైనవి.
• RowSet పట్టిక డేటా ద్వారా మరింత సరళంగా నావిగేట్ చేస్తుంది మరియు ముందుకు వెనుకకు స్క్రోల్ చేయగలదు.
• RowSet కనెక్షన్ మూసివేయబడిన తర్వాత కూడా ఉపయోగించబడే కాష్ చేసిన డేటాను నిర్వహిస్తుంది.
• RowSet కొత్త కనెక్షన్ పద్ధతికి మద్దతు ఇస్తుంది, మీరు కనెక్షన్ లేకుండా డేటాబేస్కు కనెక్ట్ చేయవచ్చు. ఇది XML డేటా మూలాన్ని చదవడానికి కూడా మద్దతు ఇస్తుంది.
• RowSet డేటా ఫిల్టర్‌కు మద్దతు ఇస్తుంది.
• RowSet టేబుల్ చేరిక కార్యకలాపాలకు కూడా మద్దతు ఇస్తుంది.

రౌసెట్ రకాలు:

• CachedRowSet
• ఫిల్టర్ చేసిన రోసెట్
• JdbcRowSet
• రోసెట్‌లో చేరండి
• WebRowSet

6.2 రోసెట్ ఆబ్జెక్ట్‌ను సృష్టిస్తోంది

పని వస్తువును పొందడానికి మూడు విభిన్న మార్గాలు ఉన్నాయి.

మొదట, ఇది శాస్త్రీయ పద్ధతిలో పొందిన ఫలితాల సెట్ నుండి డేటాతో నింపబడుతుంది .

ఉదాహరణకు, మేము CachedRowSetని ఉపయోగించి ResultSet డేటాను కాష్ చేయవచ్చు :

Statement statement = connection.createStatement();
ResultSet results = statement.executeQuery("SELECT * FROM user");
 
RowSetFactory factory = RowSetProvider.newFactory();
CachedRowSet crs = factory.createCachedRowSet();
crs.populate(results);		// Use ResultSet to populate

రెండవది, మీరు దాని కోసం మీ స్వంత డేటాబేస్ కనెక్షన్‌ని సృష్టించడం ద్వారా పూర్తిగా స్వీయ-నియంత్రణ RowSet వస్తువును సృష్టించవచ్చు :

JdbcRowSet rowSet = RowSetProvider.newFactory().createJdbcRowSet();
rowSet.setUrl("jdbc:mysql://localhost:3306/test");
rowSet.setUsername("root");
rowSet.setPassword("secret");
 
rowSet.setCommand("SELECT * FROM user");
rowSet.execute();

మరియు మూడవదిగా, మీరు ఇప్పటికే ఉన్న కనెక్షన్‌కి RowSetని కనెక్ట్ చేయవచ్చు:

Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root");
JdbcRowSet rowSet = new JdbcRowSetImpl(con);

rowSet.setCommand("SELECT * FROM user");
rowSet.execute();

6.3 RowSetతో పని చేయడానికి ఉదాహరణలు

ఉదాహరణ ఒకటి: కాషింగ్ .

మొత్తం డేటాను కాష్ చేయడానికి మరియు ఇప్పటికే మూసివేయబడిన కనెక్షన్ నుండి చదవడానికి మేము CachedRowSetని ఉపయోగించే కోడ్‌ను వ్రాస్దాం :

Statement statement = connection.createStatement();
ResultSet results = statement.executeQuery("SELECT * FROM user");

RowSetFactory factory = RowSetProvider.newFactory();
CachedRowSet crs = factory.createCachedRowSet();
crs.populate(results);	// Use ResultSet to populate

connection.close();		// Close the connection

// Cache data is still available
while(crs.next()) {
  	System.out.println(crs.getString(1)+"\t"+ crs.getString(2)+"\t"+ crs.getString(3));
}

ఉదాహరణ రెండు: RowSet ద్వారా అడ్డు వరుసలను మార్చడం :

// Connect to the database
 CachedRowSet crs = rsf.createCachedRowSet();
 crs.setUrl("jdbc:mysql://localhost/test");
 crs.setUsername("root");
 crs.setPassword("root");
 crs.setCommand("SELECT * FROM user");
 crs.execute();

// This type of operation can only change standalone RowSet
// First, move the pointer to an empty (new) string, the current position is remembered
 crs.moveToInsertRow();
 crs.updateString(1, Random.nextInt());
 crs.updateString(2, "Clone" + System.currentTimeMillis());
 crs.updateString(3, "Female");
 crs.insertRow();  // Add the current (new) line to the rest of the lines
 crs.moveToCurrentRow(); // Return a pointer to the line where it was before insertion

 crs.beforeFirst();
 while(crs.next()) {
 	System.out.println(crs.getString(1) + "," + crs.getString(2) + "," + crs.getString(3));
}

// And now we can upload all our changes to the database
Connection con = DriverManager.getConnection("jdbc:mysql://localhost/dbtest", "root", "root");
con.setAutoCommit(false); // Needed for synchronization
crs.acceptChanges(con);// Synchronize data to database

ఇది ఎలా పని చేస్తుందనే దానిపై మీకు ఆసక్తి ఉంటే, మీరు అధికారిక డాక్యుమెంటేషన్‌లో అంశాన్ని చదవవచ్చు. ప్రస్తుతానికి అది ఏమిటో చెప్పడం మాత్రమే నా పని.