ResultSet నుండి డేటాను పొందడం

ప్రస్తుత లైన్ నిర్వహణ

మేము మొదటి ప్రోగ్రామ్ వ్రాసాము మరియు అది ఖచ్చితంగా పనిచేసింది. మేము ఒక ప్రశ్నను వ్రాసాము, దానిని అమలు చేసాము మరియు ఫలితంగా, executeQuery() పద్ధతి మాకు ఒక వస్తువును అందించిందిఫలితం సెట్ఒక ప్రశ్న యొక్క అన్ని ఫలితాలను కలిగి ఉంటుంది. మరియు ఇప్పుడు మేము దాని నుండి ఈ ఫలితాలను ఎలా పొందాలో గుర్తించడానికి ప్రయత్నిస్తాము.

ప్రశ్న ఫలితం వివిధ రకాలైన వేల వరుసలు మరియు వందల కొద్దీ నిలువు వరుసలను కలిగి ఉండవచ్చు, కాబట్టి ఇది మీరు అనుకున్నంత పనికిమాలిన పని కాదు. ఉదాహరణకు, చిత్రాలను డేటాబేస్‌లో నిల్వ చేయవచ్చు, ఆపై మీరు చిత్రాన్ని బైట్‌ల సమితిగా లేదా డౌన్‌లోడ్ చేయడానికి ఇన్‌పుట్‌స్ట్రీమ్‌గా పొందవచ్చు.

కానీ మేము సరళమైన వాటితో ప్రారంభిస్తాము - “ ప్రస్తుత ఫలిత రేఖ ” అనే భావనతో . ఫలితంగా సాధారణంగా చాలా వరుసలు ఉంటాయి కాబట్టి, వస్తువుఫలితం సెట్లోపల ప్రస్తుత రేఖకు పాయింటర్ ఉంది. మరియు తదుపరి() పద్ధతిని ఉపయోగించి వాటిని చదవడానికి పంక్తులను వరుసగా మారుస్తుంది .

ఈ విధానం ప్రధానంగా ఆప్టిమైజేషన్ కోసం చేయబడుతుంది. మీరు వాటిని వరుసగా చదివే వరకు JDBC డ్రైవర్ డేటాబేస్ నుండి స్ట్రింగ్‌లను లోడ్ చేయకపోవచ్చు. మీరు కూడా ఫైల్‌ఇన్‌పుట్‌స్ట్రీమ్‌ని మొదటి నుండి చివరి వరకు వరుసగా చదవండి. కాబట్టి ఈ విధానం మీకు సుపరిచితం మరియు అర్థమయ్యేలా ఉండాలి.

అయితే, మీకు నిజంగా ఇది అవసరమైతే, RandomAccessFile క్లాస్‌ని ఉపయోగించి ఫైల్‌లను ఎక్కడైనా చదవవచ్చు .

ResultSet తరగతి కూడా ఇలాంటిదేదో అనుమతిస్తుంది మరియు మీరు ప్రస్తుత అడ్డు వరుసను ఫలితంతో పాటు ఎక్కడికైనా తరలించడానికి అనుమతిస్తుంది. దీన్ని చేయడానికి, ఇది క్రింది పద్ధతులను కలిగి ఉంది:

పద్ధతులు చాలా సులభం, కానీ రెండు వివరణలు చేయవలసి ఉంటుంది. ఫలితాలు, రెండు వైపులా ఖాళీ లైన్లతో రూపొందించబడ్డాయి. అందువల్ల, ప్రారంభంలో ప్రస్తుత పంక్తి ఫలితం యొక్క మొదటి పంక్తికి ముందు ఉంటుంది. మరియు మొదటి వరుసను పొందడానికి, మీరు కనీసం ఒక్కసారైనా తదుపరి() పద్ధతికి కాల్ చేయాలి .

మీరు చివరి వరుసలో తదుపరి() పద్ధతికి కాల్ చేసినట్లయితే , మీరు చివరి వరుస తర్వాత పంక్తికి మారారు . మీరు దాని నుండి డేటాను చదవలేరు, కానీ ఎటువంటి లోపం జరగదు. ఇక్కడ isAfterLast() మెథడ్ ఫలితంగా true అని డిక్లేర్ చేయబడుతుంది.

ఉదాహరణ:

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

System.out.println( results.getRow() );        	// 0
System.out.println( results.isBeforeFirst() );  // true
System.out.println( results.isFirst() );          	// false

results.next();

System.out.println( results.getRow() );        	// 1
System.out.println( results.isBeforeFirst() );  // false
System.out.println( results.isFirst() );          	// true

results.next();

System.out.println( results.getRow() );        	// 2
System.out.println( results.isBeforeFirst() );  // false
System.out.println( results.isFirst() );          	// false

ప్రస్తుత అడ్డు వరుస నుండి డేటాను పొందడం

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

getType(numberColumns)

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

getType(nameColumns)

ఉదాహరణ:

while (results.next()) {
        	Integer id = results.getInt(“id”);
        	String name = results.getString(“name”);
        	System.out.println(results.getRow() + ". " + id + "\t"+ name);
}

క్రింద నేను SQL డేటా రకాలు మరియు ResultSet పద్ధతులను అనుబంధించడంలో మీకు సహాయపడే పట్టికను అందిస్తాను:

పాయింట్, మీరు అర్థం చేసుకున్నారని నేను అనుకుంటున్నాను.

ResultSet గురించి విభిన్న డేటాను పొందడం

ప్రస్తుత పంక్తి నుండి డేటాను ఎలా చదవాలో మేము కనుగొన్నాము: నిలువు వరుస సంఖ్య మరియు దాని పేరు ద్వారా. మార్గం ద్వారా, నిలువు వరుస పేరును దాని సంఖ్య ద్వారా నేను ఎలా కనుగొనగలను? లేదా ఫలితంలోని నిలువు వరుసల సంఖ్యా?

ఒకవైపు రిక్వెస్ట్ రాస్తే ఇదంతా తెలుసుకోవాలని అనిపిస్తోంది. మరోవైపు, మేము స్క్రీన్‌పై ప్రశ్న యొక్క ఫలితాన్ని ప్రదర్శించే ప్రోగ్రామ్‌ను వ్రాయవచ్చు: ప్రశ్న మాకు పంపబడుతుంది మరియు SQL సర్వర్ తిరిగి వచ్చిన ప్రతిదాన్ని స్క్రీన్‌పై (కన్సోల్, వెబ్ పేజీలో) ప్రదర్శించాలనుకుంటున్నాము. మనకు.

JDBC దీని కోసం ఒక ప్రత్యేక వస్తువును కలిగి ఉంది, ResultSetMetaData ఇంటర్‌ఫేస్ . ఈ రకమైన వస్తువును పొందడం చాలా సులభం:

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

ResultSetMetaData ఇంటర్‌ఫేస్ కొన్ని ఆసక్తికరమైన పద్ధతులను కలిగి ఉంది. క్రింద అత్యంత ప్రసిద్ధమైనవి:

మన పట్టిక గురించి కొంచెం తెలుసుకోవడానికి దీనిని ఉపయోగించుకుందాం:

ResultSetMetaData metaData = results.getMetaData();
int columnCount = metaData.getColumnCount();
for (int column = 1; column <= columnCount; column++)
{
        	String name = metaData.getColumnName(column);
        	String className = metaData.getColumnClassName(column);
        	String typeName = metaData.getColumnTypeName(column);
        	int type = metaData.getColumnType(column);

        	System.out.println(name + "\t" + className + "\t" + typeName + "\t" + type);
}

ముఖ్యమైనది! నిలువు వరుసలు 1 నుండి లెక్కించబడిందని గమనించండి. అడ్డు వరుసలు కూడా. ఇది ఎంత అసాధారణమైనది, సరియైనదా?

మరియు ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత నాకు లభించిన ఫలితం ఇది: