Gruntle Software & Testing

JDBC ಫಲಿತಾಂಶ ಸೆಟ್: ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು Java ResultSet ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ಇವರು Stewart Tristianಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ ಮಾರ್ಗದರ್ಶಕರು

ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು JDBC ResultSet ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಈ ಟ್ಯುಟೋರಿಯಲ್ ವಿವರಿಸುತ್ತದೆ. ನಾವು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ResultSetMetaData ಮತ್ತು DatabaseMetaData ಇಂಟರ್ಫೇಸ್‌ಗಳ ಕುರಿತು ಸಹ ಕಲಿಯುತ್ತೇವೆ:

JDBC DriverManager JDBC ಟ್ಯುಟೋರಿಯಲ್ ಸರಣಿಯ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು JDBC ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ಕಲಿತಿದ್ದೇವೆ ಡ್ರೈವರ್‌ಮ್ಯಾನೇಜರ್ ಮತ್ತು ಅದರ ವಿಧಾನಗಳು, ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ JDBC ಸಿದ್ಧಪಡಿಸಿದ ಹೇಳಿಕೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನಲ್ಲಿ, ನಾವು JDBC ಯಲ್ಲಿ ಉಳಿದಿರುವ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ. ನಮ್ಮ ಹಿಂದಿನ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳಲ್ಲಿ ನಾವು ಸ್ಟೇಟ್‌ಮೆಂಟ್, ಸಿದ್ಧಪಡಿಸಿದ ಹೇಳಿಕೆ ಮತ್ತು ಕರೆ ಮಾಡಬಹುದಾದ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದೇವೆ.

ಇಲ್ಲಿ, ನಾವು JDBC ResultSet, ResultSetMetaData, ಮತ್ತು DatabaseMetaData ಇಂಟರ್‌ಫೇಸ್‌ಗಳು, ಅವುಗಳ ವಿಧಾನಗಳು ಮತ್ತು ಜಾವಾ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ವಿಧಾನಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ಕಲಿಯುತ್ತೇವೆ.

JDBC ResultSet ಇಂಟರ್‌ಫೇಸ್

ResultSet ಇಂಟರ್‌ಫೇಸ್ java.sql ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿದೆ. ಜಾವಾ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ SQL ಹೇಳಿಕೆಗಳ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ಡೇಟಾಬೇಸ್ ಕೋಷ್ಟಕದಿಂದ ಹಿಂತಿರುಗಿದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ResultSet ನ ವಸ್ತುವು ಫಲಿತಾಂಶದ ಡೇಟಾದಲ್ಲಿ ಕರ್ಸರ್ ಪಾಯಿಂಟ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಫಲಿತಾಂಶದ ಡೇಟಾದ ಮೊದಲ ಸಾಲಿನ ಮೊದಲು ಕರ್ಸರ್ ಸ್ಥಾನಗಳನ್ನು ಹೊಂದಿದೆ.

ಮುಂದಿನ() ವಿಧಾನವನ್ನು ಮುಂದಿನ ದಿಕ್ಕಿನಲ್ಲಿ ಕರ್ಸರ್ ಅನ್ನು ಮುಂದಿನ ಸ್ಥಾನಕ್ಕೆ ಸರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ದಾಖಲೆಗಳಿಲ್ಲದಿದ್ದರೆ ಅದು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಯಾವುದೇ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು executeQuery() ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ಇದು ಹೇಳಿಕೆ ಅಥವಾ ಸಿದ್ಧಪಡಿಸಿದ ಹೇಳಿಕೆ ಅಥವಾ ಕರೆಯಬಹುದಾದ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ವಸ್ತುವಾಗಿರಬಹುದು. ಸಿದ್ಧಪಡಿಸಿದ ಹೇಳಿಕೆ, ಮತ್ತುಕಾಲಮ್‌ನ ಟೇಬಲ್‌ನ ಸ್ಕೀಮಾ ಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ int getColumnCount() ಇದು ResultSet ನ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ boolean isAutoIncrement(int Column) ನೀಡಿದ ಕಾಲಮ್ ಸ್ವಯಂ ಏರಿಕೆಯಾಗಿದ್ದರೆ ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು boolean isCaseSensitive(int Column) ನೀಡಿರುವ ಕಾಲಮ್ ಕೇಸ್ ಸೆನ್ಸಿಟಿವ್ ಆಗಿದ್ದರೆ ಅದು ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು

ResultSetMetaData ಉದಾಹರಣೆ 

package com.STH.JDBC; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Statement; public class ResultSetMetaData_Example { public static void main(String[] args) throws ClassNotFoundException, SQLException { // TODO Auto-generated method stub String QUERY= " select * from employee_details"; Class.forName("oracle.jdbc.driver.OracleDriver"); try(Connection conn = DriverManager.getConnection("jdbc:oracle:thin:system/pass123@localhost:1521:XE")) { Statement statemnt1 = conn.createStatement(); ResultSet rs1 =null; rs1 = statemnt1.executeQuery(QUERY); ResultSetMetaData rsmd = rs1.getMetaData(); System.out.println(" We are using ResultSetMetaData "); System.out.println("No: of Columns: "+ rsmd.getColumnCount()); System.out.println("ColumnName of Column 1: "+ rsmd.getColumnName(1)); System.out.println("Data Type of Column 2: " + rsmd.getColumnTypeName(2)); System.out.println("Table Name of the Column 1: " + rsmd.getTableName(1)); System.out.println("Schema Name of the Column 1: " + rsmd.getSchemaName(1)); } } }

ಔಟ್‌ಪುಟ್:

ವಿವರಣೆ:

ಮೇಲಿನ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ResultSetMetaData ಇಂಟರ್‌ಫೇಸ್‌ನಲ್ಲಿ ನಾವು getColumnCount(),getColumnName(), getColumnTypeName(), getTableName() ಮತ್ತು getSchemaName() ವಿಧಾನಗಳನ್ನು ಅಳವಡಿಸಿದ್ದೇವೆ.

DatabaseMetaData

DatabaseMetaData ನಂತಹ ಡೇಟಾಬೇಸ್ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ. ಡೇಟಾಬೇಸ್ ಹೆಸರು, ಡೇಟಾಬೇಸ್ ಆವೃತ್ತಿ, ಹೀಗೆ> String getDriverName() ಇದು ನಮ್ಮ Java ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾವು ಬಳಸುತ್ತಿರುವ JDBC ಡ್ರೈವರ್‌ನ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ getDriverVersion() ಇದು JDBC ಚಾಲಕ ಆವೃತ್ತಿ ಸಂಖ್ಯೆ String getUserName() ಇದು ನಾವು ಬಳಸುತ್ತಿರುವ ಡೇಟಾಬೇಸ್‌ನ ಬಳಕೆದಾರಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ String getDatabaseProductName() ಇದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ನಾವು ಇರುವ ಡೇಟಾಬೇಸ್‌ನ ಹೆಸರುಬಳಸಿಕೊಂಡು String getDatabaseProductVersion() ಇದು ನಾವು ಬಳಸುತ್ತಿರುವ ಡೇಟಾಬೇಸ್‌ನ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ResultSet getSchemas() ಇದು ಸಂಪರ್ಕಿತ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಸ್ಕೀಮಾಗಳ ಹೆಸರುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ String getStringFunctions() ಇದು ಸಂಪರ್ಕಿತ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಸ್ಟ್ರಿಂಗ್ ಫಂಕ್ಷನ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ String getTimeDateFunctions() ಇದು ಸಂಪರ್ಕಿತ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಸಮಯ ಮತ್ತು ದಿನಾಂಕ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ getURL() ಇದು ಡೇಟಾಬೇಸ್‌ಗಾಗಿ URL ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Boolean isReadOnly() ಇದು ಡೇಟಾಬೇಸ್ ಓದಲು-ಮಾತ್ರ ಮೋಡ್‌ನಲ್ಲಿದೆಯೇ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Boolean supportsBatchUpdates() ಇದು ಡೇಟಾಬೇಸ್ ಬೆಂಬಲ ಬ್ಯಾಚ್ ನವೀಕರಣಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Boolean supportsSavepoints() ಡೇಟಾಬೇಸ್ Savepoints ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Boolean supportsStatementPooling() ಡೇಟಾಬೇಸ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಪೂಲಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಬೂಲಿಯನ್ ಬೆಂಬಲಿಸುತ್ತದೆStoredProcedures() ಇದು ಡೇಟಾಬೇಸ್ ಸಂಗ್ರಹಿಸಿದ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ Boolean supportsOuterJoins() ಇದು ಡೇಟಾಬೇಸ್ ಔಟರ್ ಜಾಯ್ನ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ

ಇಲ್ಲಿ, ನಾವು ಡೇಟಾಬೇಸ್‌ಮೆಟಾಡೇಟಾ ಇಂಟರ್‌ಫೇಸ್‌ನ ಕೆಲವು ಪ್ರಮುಖ ವಿಧಾನಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿದ್ದೇವೆ. ನೀವು ಉಲ್ಲೇಖಿಸಬಹುದುಡೇಟಾಬೇಸ್‌ಮೆಟಾಡೇಟಾ ಇಂಟರ್‌ಫೇಸ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ವಿಧಾನಗಳನ್ನು ನೀವು ನೋಡಬಹುದಾದ Oracle ನ ಅಧಿಕೃತ ಸೈಟ್.

DatabaseMetaData ಉದಾಹರಣೆ: 

package com.STH.JDBC; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Statement; public class DatabaseMetaData_Example { public static void main(String[] args) throws ClassNotFoundException, SQLException { // TODO Auto-generated method stub Class.forName("oracle.jdbc.driver.OracleDriver"); Connection conn = DriverManager.getConnection("jdbc:oracle:thin:system/pass123@localhost:1521:XE"); DatabaseMetaData dbmd = conn.getMetaData(); System.out.println("Using DatabaseMetaData"); System.out.println("Driver Name: " + dbmd.getDriverName()); System.out.println("Driver Version: "+ dbmd.getDriverVersion()); System.out.println("UserName of the Database: " + dbmd.getUserName()); System.out.println("Database Product Name:" + dbmd.getDatabaseProductName()); System.out.println("Database Product Version: " + dbmd.getDatabaseProductVersion()); System.out.println("List of String Functions in the Database: " + dbmd.getStringFunctions()); System.out.println("List of Time & Date functions in the Database: " + dbmd.getTimeDateFunctions()); System.out.println("URL of the Database: " + dbmd.getURL()); System.out.println("Database is read - only? " +dbmd.isReadOnly()); System.out.println("Support Batch Updates? " + dbmd.supportsBatchUpdates()); System.out.println("Support savepoints? " + dbmd.supportsSavepoints()); System.out.println("Support Statement Pooling? "+ dbmd.supportsStatementPooling()); System.out.println("Support Stored Procedures? " + dbmd.supportsStoredProcedures()); System.out.println("Support Outer Join? "+ dbmd.supportsOuterJoins()); } }

ಔಟ್‌ಪುಟ್:

ವಿವರಣೆ:

ಮೇಲಿನ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ನಾವು getDriverName(), getDriverVersion() ಅನ್ನು ಬಳಸಿದ್ದೇವೆ/ ಅಳವಡಿಸಿದ್ದೇವೆ , getUserName(), getDatabaseProductName(), getDatabaseProductVersion(), getStringFunctions(), getTimeDateFunctions(), getURL(), isReadOnly(), supportsBatchUpdates(), supportsStatementPooling(), supportsSavepoints(PoundsSavepoints) ವಿಧಾನಗಳಲ್ಲಿ ಬೆಂಬಲಿಸುತ್ತದೆ DatabaseMetaData ಇಂಟರ್‌ಫೇಸ್.

ಗಮನಿಸಬೇಕಾದ ಅಂಶಗಳು:

  • JDBC ResultSet ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಡೇಟಾಬೇಸ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಅದನ್ನು ನಮ್ಮ ಜಾವಾ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಬಳಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
  • ಅಪ್‌ಡೇಟ್‌XXX() ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು ನಾವು ResultSet ಅನ್ನು ಸಹ ಬಳಸಬಹುದು.
  • ResultSet ವಸ್ತುವು ಫಲಿತಾಂಶದ ಡೇಟಾದ ಮೊದಲ ಸಾಲಿನ ಮೊದಲು ಕರ್ಸರ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಮುಂದಿನ() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ResultSet ಮೂಲಕ ಪುನರಾವರ್ತಿಸಬಹುದು.
  • ResultSet ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಮತ್ತಷ್ಟು ಚಲಿಸಲು ResultSet ನ ನ್ಯಾವಿಗೇಷನಲ್ ವಿಧಾನಗಳನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ
  • ResultMetaData ಅನ್ನು ಫಲಿತಾಂಶ ಸೆಟ್‌ನ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ ಕಾಲಮ್ ಹೆಸರು, ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ, ಕಾಲಮ್‌ನ ಡೇಟಾ ಪ್ರಕಾರ, ಇತ್ಯಾದಿ.
  • ನಾವು ಸಂಪರ್ಕಿಸಿರುವ ಡೇಟಾಬೇಸ್ ಕುರಿತು ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು DatabaseMetData ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

Q #1) ಇದರ ಉಪಯೋಗವೇನುResultSet?

ಉತ್ತರ: DB ಯಿಂದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ResultSet ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. executeQuery() ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಅದು ResultSet ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ತರ್ಕವನ್ನು ನಿರ್ವಹಿಸಲು ನಾವು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಫಲಿತಾಂಶ ಸೆಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಬಹುದು.

Q #2) ResultSet ಖಾಲಿಯಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುವುದು ಹೇಗೆ?

ಉತ್ತರ: IsResultSet ಖಾಲಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಉದ್ದ(), ಗಾತ್ರ() ನಂತಹ ಯಾವುದೇ ಪೂರ್ವನಿರ್ಧರಿತ ವಿಧಾನಗಳು ಲಭ್ಯವಿಲ್ಲ. ನಾವು ಪುನರಾವರ್ತಿಸಲು ಮುಂದಿನ() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಅದು ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸಿದರೆ, ಅದು ಖಾಲಿಯಾಗಿಲ್ಲ, ಅದು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸಿದರೆ ಫಲಿತಾಂಶಸೆಟ್ ಖಾಲಿಯಾಗಿದೆ ಎಂದರ್ಥ.

Q #3) ResultSet ಸಾಧ್ಯವೇ ಶೂನ್ಯವಾಗಿರಬಹುದೇ?

ಉತ್ತರ: ಇಲ್ಲ, executeQuery() ವಿಧಾನವು ಎಂದಿಗೂ ಶೂನ್ಯವಾಗಿರದ ಫಲಿತಾಂಶಸೆಟ್ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

Q #4) ಅಪ್‌ಡೇಟ್ ಮಾಡಬಹುದಾದ ಫಲಿತಾಂಶ ಸೆಟ್ ಎಂದರೇನು?

ಉತ್ತರ: ಕಾಲಮ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು, ಕಾಲಮ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಮತ್ತು ಸಾಲುಗಳನ್ನು ಅಳಿಸಲು ನವೀಕರಿಸಬಹುದಾದ ಫಲಿತಾಂಶಸೆಟ್ ವಸ್ತುವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ResultSet ಅನ್ನು ನವೀಕರಿಸಬಹುದಾದಂತೆ ಮಾಡಲು, ನಾವು ಸ್ಕ್ರಾಲ್ ಪ್ರಕಾರವನ್ನು ಸೂಕ್ಷ್ಮ ಅಥವಾ ಸೂಕ್ಷ್ಮವಲ್ಲದ ಮತ್ತು CONCUR ಪ್ರಕಾರವನ್ನು ನವೀಕರಿಸುವ ರೀತಿಯಲ್ಲಿ ಮಾಡಬೇಕಾಗಿದೆ. 

ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE.

Q #5) ಸಂಪರ್ಕಗೊಂಡಿರುವ ಡೇಟಾಬೇಸ್ ಹೆಸರನ್ನು ಹೇಗೆ ಪಡೆಯುವುದು?

ಉತ್ತರ: ನಾವು ಡೇಟಾಬೇಸ್‌ಮೆಟಾಡೇಟಾ ಆಬ್ಜೆಕ್ಟ್‌ನ getDatabaseProductName() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.

ತೀರ್ಮಾನ

ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನಲ್ಲಿ, ನಾವು ಏನೆಂದು ಚರ್ಚಿಸಿದ್ದೇವೆ ResultSet, ResultSetMetaData, ಮತ್ತು DatabaseMetaData ಇಂಟರ್‌ಫೇಸ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಪ್ರಮುಖ ವಿಧಾನಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ JDBC ಪ್ರೋಗ್ರಾಂಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಾವೂ ನೋಡಿದ್ದೇವೆResultSet ಅನ್ನು ಬಳಸಿಕೊಂಡು DB ಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಹೇಗೆ ನವೀಕರಿಸುವುದು. ResultSetMetadata ಕಾಲಮ್ ಹೆಸರು, ಕಾಲಮ್ ಎಣಿಕೆ, ಮತ್ತು ಮುಂತಾದವುಗಳಂತಹ ResultSet ಕುರಿತು ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.

DatabaseMetaData ಡೇಟಾಬೇಸ್ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.

>

ಕರೆಯಬಹುದಾದ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಂಟರ್‌ಫೇಸ್‌ಗಳು ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಂಟರ್‌ಫೇಸ್‌ನ ಉಪ-ಇಂಟರ್‌ಫೇಸ್‌ಗಳಾಗಿವೆ.

ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಂಟರ್‌ಫೇಸ್ 

Statement statemnt1 = conn.createStatement(); ResultSet rs1 = statemnt1.executeQuery(“Select * from EMPLOYEE_DETAILS”);

ಸಿದ್ಧಪಡಿಸಿದ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಇಂಟರ್‌ಫೇಸ್ 

PreparedStatement pstatemnt1 = conn.prepareStatement(insert_query); ResultSet rs1 = pstatemnt1.executeQuery(“Select * from EMPLOYEE_DETAILS”);

ನಾವು ಮಾಡಬಹುದು ಫಲಿತಾಂಶಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆ ಮಾಡುವಾಗ ಕಾಲಮ್‌ಗಳ ಡೇಟಾವನ್ನು ಪಡೆಯಲು getX() ವಿಧಾನವನ್ನು ಬಳಸಿ ಅಲ್ಲಿ X – ಕಾಲಮ್‌ನ ಡೇಟಾಟೈಪ್ ಆಗಿರುತ್ತದೆ. getX() ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ನಾವು ಕಾಲಮ್ ಹೆಸರುಗಳು ಅಥವಾ ಸೂಚಿಯನ್ನು ಬಳಸಬಹುದು. 

while(rs1.next()) { int empNum = rs1.getInt("empNum"); String lastName = rs1.getString("lastName"); String firstName = rs1.getString("firstName"); String email = rs1.getString("email"); String deptNum = rs1.getString("deptNum"); String salary = rs1.getString("salary"); System.out.println(empNum + "," +lastName+ "," +firstName+ "," +email +","+deptNum +"," +salary); }

ನಾವು getX() ವಿಧಾನಗಳಲ್ಲಿ ಕಾಲಮ್ ಹೆಸರಿನ ಬದಲಿಗೆ ಕಾಲಮ್‌ನ ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆಯನ್ನು ಸಹ ನಮೂದಿಸಬಹುದು. 

while(rs1.next()) { int empNum = rs1.getInt(1); String lastName = rs1.getString(2); String firstName = rs1.getString(3); String email = rs1.getString(4); String deptNum = rs1.getString(5); String salary = rs1.getString(6); System.out.println(empNum + "," +lastName+ "," +firstName+ "," +email +","+deptNum +"," +salary); }

ResultSet ವಿಧಗಳು

ಡೀಫಾಲ್ಟ್‌ನಲ್ಲಿ, ನಾವು ResultSet ನಲ್ಲಿ ಡೇಟಾ/ಮೌಲ್ಯಗಳನ್ನು ಪುನರಾವರ್ತನೆ ಮಾಡಬಹುದು ಅದು ಮುಂದೆ ದಿಕ್ಕಿನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದ SQL ಹೇಳಿಕೆಯ ಔಟ್‌ಪುಟ್‌ನಂತೆ ಹಿಂತಿರುಗಿದೆ. Scrollable ResultSet ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಇತರ ದಿಕ್ಕುಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದು. ನಾವು ಸ್ಟೇಟ್‌ಮೆಂಟ್, ಪ್ರಿಪೇರ್ಡ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಮತ್ತು ಕರೆ ಮಾಡಬಹುದಾದ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ ಫಲಿತಾಂಶ ಸೆಟ್‌ನ ಪ್ರಕಾರ ಮತ್ತು ಏಕಕಾಲಿಕತೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ರಿಸಲ್ಟ್‌ಸೆಟ್‌ನಲ್ಲಿ 3 ವಿಧಗಳಿವೆ. ಅವುಗಳೆಂದರೆ:

  1. TYPE_FORWARD_ONLY: ಇದು ಡೀಫಾಲ್ಟ್ ಆಯ್ಕೆಯಾಗಿದೆ, ಅಲ್ಲಿ ಕರ್ಸರ್ ಪ್ರಾರಂಭದಿಂದ ಅಂತ್ಯಕ್ಕೆ ಅಂದರೆ ಮುಂದಕ್ಕೆ ಚಲಿಸುತ್ತದೆ.
  2. TYPE_SCROLL_INSENSITIVE: ಈ ಪ್ರಕಾರದಲ್ಲಿ, ಇದು ಕರ್ಸರ್ ಅನ್ನು ಮುಂದಕ್ಕೆ ಮತ್ತು ಹಿಂದಕ್ಕೆ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾವನ್ನು ಪುನರಾವರ್ತಿಸುವಾಗ ನಾವು ಡೇಟಾದಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದರೆ, ಯಾರಾದರೂ DB ಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಬದಲಾಯಿಸಿದರೆ ಅದು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ನವೀಕರಿಸುವುದಿಲ್ಲ. ಏಕೆಂದರೆ ಡೇಟಾಸೆಟ್ SQL ಪ್ರಶ್ನೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ಸಮಯದ ಡೇಟಾವನ್ನು ಹೊಂದಿದೆಡೇಟಾ.
  3. TYPE_SCROLL_SENSITIVE: ಇದು TYPE_SCROLL_INSENSITIVE ಗೆ ಹೋಲುತ್ತದೆ, ವ್ಯತ್ಯಾಸವೆಂದರೆ SQL ಪ್ರಶ್ನೆಯು ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸಿದ ನಂತರ ಯಾರಾದರೂ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಿದರೆ, ಅದು ಡೇಟಾಸೆಟ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.

ResultSet Concurrency

ResultSet ನಲ್ಲಿ 2 ಮೋಡ್‌ಗಳ ಏಕಕಾಲಿಕತೆಯಿದೆ. ಅವುಗಳೆಂದರೆ:

  1. ResultSet.CONCUR_READ_ONLY: ಇದು ಡೀಫಾಲ್ಟ್ ಕನ್ಕರೆನ್ಸಿ ಮೋಡ್ ಆಗಿದೆ. ನಾವು ಫಲಿತಾಂಶ ಸೆಟ್‌ನಲ್ಲಿರುವ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಓದಬಹುದು. ನವೀಕರಣವು ಅನ್ವಯಿಸುವುದಿಲ್ಲ.
  2. ResultSet.CONCUR_UPDATABLE: ನಾವು ResultSet ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಬಹುದು.

ಕೆಲವು ಡೇಟಾಬೇಸ್‌ಗಳು ಎಲ್ಲದಕ್ಕೂ ಏಕಕಾಲಿಕ ಮೋಡ್ ಅನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ ಫಲಿತಾಂಶ ಸೆಟ್ ಪ್ರಕಾರಗಳು. ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರು supportsResultSetConcurrency() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮ ಅಪೇಕ್ಷಿತ ಪ್ರಕಾರ ಮತ್ತು ಏಕಕಾಲಿಕ ಮೋಡ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತಾರೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ.

ResultSet ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿನ ವಿಧಾನಗಳು

ResultSet ವಿಧಾನಗಳಲ್ಲಿ 4 ವರ್ಗಗಳಿವೆ. ಅವುಗಳೆಂದರೆ:

  1. ನ್ಯಾವಿಗೇಷನಲ್ ವಿಧಾನಗಳು
  2. ಗೆಟ್ಟರ್ ವಿಧಾನಗಳು
  3. ಸೆಟರ್ ವಿಧಾನಗಳು
  4. ವಿವಿಧ ವಿಧಾನಗಳು

ಮೊದಲಿಗೆ, ನಾವು ನ್ಯಾವಿಗೇಷನಲ್ ವಿಧಾನಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಮತ್ತಷ್ಟು ಚಲಿಸುತ್ತೇವೆ.

#1) ನ್ಯಾವಿಗೇಷನಲ್ ವಿಧಾನಗಳು

ಡೇಟಾಸೆಟ್ ಸುತ್ತಲೂ ಕರ್ಸರ್ ಅನ್ನು ಸರಿಸಲು ಈ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

  • ಬೂಲಿಯನ್ ಸಂಪೂರ್ಣ(ಇಂಟ್ ಸಾಲು): ಇದನ್ನು ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ನಿರ್ದಿಷ್ಟ ಸಾಲಿಗೆ ಕರ್ಸರ್ ಅನ್ನು ಸರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯು ಯಶಸ್ವಿಯಾದರೆ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
  • ಅನೂರ್ಜಿತafterLast(): ಇದು ResultSet ಕರ್ಸರ್ ಅನ್ನು ಕೊನೆಯ ಸಾಲಿನ ನಂತರ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.
  • Void beforeFirst(): ಇದು ResultSet ಕರ್ಸರ್ ಅನ್ನು ಮೊದಲ ಸಾಲಿನ ಮೊದಲು ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.
  • ಬೂಲಿಯನ್ ಫಸ್ಟ್(): ಇದು ResultSet ಕರ್ಸರ್ ಅನ್ನು ಮೊದಲ ಸಾಲಿಗೆ ಸರಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಕಾರ್ಯಾಚರಣೆ ಯಶಸ್ವಿಯಾದರೆ ಅದು ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು.
  • ಬೂಲಿಯನ್ ಕೊನೆಯ(): ಇದು ResultSet ಕರ್ಸರ್ ಅನ್ನು ಕೊನೆಯ ಸಾಲಿಗೆ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಕಾರ್ಯಾಚರಣೆಯು ಯಶಸ್ವಿಯಾದರೆ ಅದು ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು.
  • ಬೂಲಿಯನ್ ಮುಂದಿನ(): ಇದು ಫಲಿತಾಂಶಸೆಟ್ ಕರ್ಸರ್ ಅನ್ನು ಮುಂದಿನ ಸಾಲಿಗೆ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚಿನ ದಾಖಲೆಗಳಿದ್ದಲ್ಲಿ ಅದು ಸರಿ ಮತ್ತು ಹೆಚ್ಚಿನ ದಾಖಲೆಗಳಿಲ್ಲದಿದ್ದರೆ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
  • ಬೂಲಿಯನ್ ಹಿಂದಿನ(): ಇದು ಫಲಿತಾಂಶಸೆಟ್ ಕರ್ಸರ್ ಅನ್ನು ಹಿಂದಿನ ಸಾಲಿಗೆ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ಕಾರ್ಯಾಚರಣೆಯು ಯಶಸ್ವಿಯಾದರೆ ಅದು ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ತಪ್ಪು.
  • ಬೂಲಿಯನ್ ಸಂಬಂಧಿ(): ಇದು ಕರ್ಸರ್ ಅನ್ನು ಮುಂದಕ್ಕೆ ಅಥವಾ ಹಿಂದಕ್ಕೆ ನೀಡಿದ ಸಾಲುಗಳ ಸಂಖ್ಯೆಗೆ ಚಲಿಸುತ್ತದೆ.
  • Int getRow(): ಇದು ResultSet ಆಬ್ಜೆಕ್ಟ್ ಈಗ ಸೂಚಿಸುತ್ತಿರುವ ಪ್ರಸ್ತುತ ಸಾಲು ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
  • Void moveToCurrentRow(): ಇದು ಕರ್ಸರ್ ಅನ್ನು ಹಿಂದಕ್ಕೆ ಸರಿಸುತ್ತದೆ ಪ್ರಸ್ತುತ ಸಾಲು ಸೇರಿಸುವ ಸಾಲಿನಲ್ಲಿದ್ದರೆ ಪ್ರಸ್ತುತ ಸಾಲು.
  • Void moveToInsertRow(): ಇದು ಸಾಲನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಸೇರಿಸಲು ನಿರ್ದಿಷ್ಟ ಸಾಲಿಗೆ ಕರ್ಸರ್ ಅನ್ನು ಸರಿಸುತ್ತದೆ. ಇದು ಪ್ರಸ್ತುತ ಕರ್ಸರ್ ಸ್ಥಳವನ್ನು ನೆನಪಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ನಾವು ಅಳವಡಿಕೆಯ ನಂತರ ಪ್ರಸ್ತುತ ಸಾಲಿಗೆ ಕರ್ಸರ್ ಅನ್ನು ಸರಿಸಲು MoveToCurrentRow() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ,ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಜಾವಾದಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ನಾವು Java 8 ಆವೃತ್ತಿ ಮತ್ತು Oracle DB ಅನ್ನು ಬಳಸಿದ್ದೇವೆ.

>>ನೀವು Oracle ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಇಲ್ಲಿಂದ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು

>>ನೀವು ಜಾವಾ ಆವೃತ್ತಿ 8 ಅನ್ನು ಇಲ್ಲಿಂದ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು

ಇದು ಹಂತ-ಹಂತದ ಜಾವಾ ಸ್ಥಾಪನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೊಂದಿದೆ.

JDBC ResultSet ಉದಾಹರಣೆ ಕಾರ್ಯಕ್ರಮ:(ನ್ಯಾವಿಗೇಷನಲ್ ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದು) 

package com.STH.JDBC; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class ResultSet_Example { public static void main(String[] args) throws ClassNotFoundException { // TODO Auto-generated method stub //Select query String select_query = "select * from employee_details"; Class.forName("oracle.jdbc.driver.OracleDriver"); //Connecting to Oracle DB try(Connection conn = DriverManager.getConnection("jdbc:oracle:thin:system/pass123@localhost:1521:X E")) { //Creating DatabaseMetaData object DatabaseMetaData dbmd = conn.getMetaData(); //Checking whether the driver supports scroll sensitive type and concur updatable boolean isSupportResultSetType = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); if(isSupportResultSetType == true) { // Creating prepared Statement PreparedStatement pstatemnt1 = conn.prepareStatement(select_query,ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet. CONCUR_UPDATABLE); ResultSet rs = pstatemnt1.executeQuery(); //Moving the cursor to point first row rs.first(); System.out.println("FIRST ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point last row rs.last(); System.out.println("LAST ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point before first row rs.beforeFirst(); System.out.println("Cursor is pointing at before the first row. Use next() to move in forward direction"); //Moving the cursor to point first row using next() rs.next(); System.out.println("FIRST ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point after last row rs.afterLast(); System.out.println("Cursor is pointing at after the last row. Use previous() to move in backward direction"); //Moving the cursor to point last row using previous() rs.previous(); System.out.println("LAST ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point third row rs.absolute(3); System.out.println("Cursor is pointing at 3rd row"); System.out.println("THIRD ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point previous row of third row rs.relative(-1); System.out.println("Cursor is pointing to the 1 row previous to the 3rd row"); System.out.println("Second ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point 4th row after the 2nd row rs.relative(4); System.out.println("Cursor is pointing to the 4th row after the 2nd row"); System.out.println("SIXTH ROW \n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point current row System.out.println(" Current Row = " + rs.getRow()); } } catch (SQLException e) { e.printStackTrace(); } } }

ಔಟ್‌ಪುಟ್:

ಉದ್ಯೋಗಿ_ವಿವರಗಳ ಕೋಷ್ಟಕದಲ್ಲಿನ ಡೇಟಾ

ವಿವರಣೆ:

ಮೇಲಿನ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾವು ಮೊದಲ(), ಕೊನೆಯ(), ಮೊದಲು ಮೊದಲ(), ನಂತರ ಕೊನೆಯ(), ಮುಂದಿನ( ResultSet ನಲ್ಲಿ ಹಿಂದಿನ(), ಸಂಪೂರ್ಣ(), ಸಂಬಂಧಿ() ಮತ್ತು getRow() ವಿಧಾನಗಳು. ಈ ವಿಧಾನಗಳನ್ನು ಬಳಸಲು ನಾವು ಸಿದ್ಧಪಡಿಸುವ ಸ್ಟೇಟ್‌ಮೆಂಟ್ ವಿಧಾನದಲ್ಲಿ ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ.

ಮುಂದೆ, ಫಲಿತಾಂಶ ಸೆಟ್‌ನಲ್ಲಿ ಗೆಟರ್ ವಿಧಾನಗಳು ಯಾವುವು ಎಂಬುದನ್ನು ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ:

#2) ಗೆಟರ್ ವಿಧಾನಗಳು

ResultSet ಡೇಟಾಬೇಸ್‌ನಿಂದ ಟೇಬಲ್‌ನ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿದೆ. ಫಲಿತಾಂಶ ಸೆಟ್‌ನಲ್ಲಿ ಟೇಬಲ್‌ನ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಗೆಟರ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಅದಕ್ಕಾಗಿ, ನಾವು ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್ ಮೌಲ್ಯ ಅಥವಾ ಕಾಲಮ್ ಹೆಸರನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ.

ಕೆಳಗಿನವುಗಳು ResultSet ನಲ್ಲಿ ಪಡೆಯುವ ವಿಧಾನಗಳಾಗಿವೆ:

  • int getInt (int ColumnIndex): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಮೌಲ್ಯವನ್ನು ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿ ಪಡೆಯಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
  • float getFloat(int ColumnIndex): ಇದನ್ನು ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಮೌಲ್ಯ.
  • java.sql.dategetDate(int ColumnIndex): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಮೌಲ್ಯವನ್ನು ದಿನಾಂಕ ಮೌಲ್ಯವಾಗಿ ಪಡೆಯಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
  • int getInt(String ColumnName): ಇದನ್ನು ಪಡೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯ.
  • float getFloat(String ColumnName): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿ ಪಡೆಯಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
  • Java.sql.date getDate(String ColumnName): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ದಿನಾಂಕ ಮೌಲ್ಯವಾಗಿ ಪಡೆಯಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಗೆಟರ್ ವಿಧಾನಗಳಿವೆ ಎಲ್ಲಾ ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ (ಬೂಲಿಯನ್, ಲಾಂಗ್, ಡಬಲ್) ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಕೂಡ ResultSet ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ. ಡೇಟಾಬೇಸ್‌ನಿಂದಲೂ ನಾವು ಅರೇ ಮತ್ತು ಬೈನರಿ ಪ್ರಕಾರದ ಡೇಟಾವನ್ನು ಪಡೆಯಬಹುದು. ಇದು ಅದಕ್ಕೆ ವಿಧಾನಗಳನ್ನು ಸಹ ಹೊಂದಿದೆ.

#3) ಸೆಟ್ಟರ್/ಅಪ್‌ಡೇಟರ್ ವಿಧಾನಗಳು

ನಾವು ಫಲಿತಾಂಶ ಸೆಟ್ ಅಪ್‌ಡೇಟರ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸಬಹುದು. ಇದು ಗೆಟರ್ ವಿಧಾನಗಳನ್ನು ಹೋಲುತ್ತದೆ, ಆದರೆ ಇಲ್ಲಿ ನಾವು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ನವೀಕರಿಸಲು ನಿರ್ದಿಷ್ಟ ಕಾಲಮ್‌ಗೆ ಮೌಲ್ಯಗಳು/ ಡೇಟಾವನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ.

ಕೆಳಗಿನವುಗಳು ResultSet ನಲ್ಲಿ ಅಪ್‌ಡೇಟ್ ಮಾಡುವ ವಿಧಾನಗಳಾಗಿವೆ:

  • ಅನೂರ್ಜಿತ updateInt(int ColumnIndex, int Value): ಇದನ್ನು ಇಂಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
  • ಶೂನ್ಯ updateFloat(int ColumnIndex, float f): ಇದನ್ನು ಫ್ಲೋಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಇಂಡೆಕ್ಸ್‌ನ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
  • ಅನೂರ್ಜಿತವಾದ updateDate(int ColumnIndex, Date d): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್ ಸೂಚ್ಯಂಕದ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆದಿನಾಂಕ ಮೌಲ್ಯದೊಂದಿಗೆ.
  • ಅನೂರ್ಜಿತ updateInt(String ColumnName, int Value): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ನೀಡಿರುವ ಇಂಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ ನವೀಕರಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
  • ಅನೂರ್ಜಿತ ಅಪ್‌ಡೇಟ್‌ಫ್ಲೋಟ್(ಸ್ಟ್ರಿಂಗ್ ಕಾಲಮ್‌ನೇಮ್, ಫ್ಲೋಟ್ ಎಫ್): ನೀಡಿರುವ ಫ್ಲೋಟ್ ಮೌಲ್ಯದೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ನವೀಕರಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
  • Java.sql.date getDate(String ColumnName): ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ನ ಮೌಲ್ಯವನ್ನು ನೀಡಲಾದ ದಿನಾಂಕ ಮೌಲ್ಯದೊಂದಿಗೆ ನವೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಎಲ್ಲಾ ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ (ಬೂಲಿಯನ್, ಉದ್ದ, ಡಬಲ್) ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಅಪ್‌ಡೇಟರ್ ವಿಧಾನಗಳಿವೆ ResultSet ಇಂಟರ್‌ಫೇಸ್‌ನಲ್ಲಿಯೂ ಸಹ.

ಅಪ್‌ಡೇಟರ್ ವಿಧಾನಗಳು ResultSet ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಿ. insertRow ಅಥವಾ updateRow ವಿಧಾನಕ್ಕೆ ಕರೆ ಮಾಡಿದ ನಂತರ ಮೌಲ್ಯಗಳನ್ನು DB ಯಲ್ಲಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಸಾಲನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ:

ನಾವು updateX() ವಿಧಾನಗಳಿಗೆ ಕರೆ ಮಾಡುವ ಮೂಲಕ ಸತತವಾಗಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಬಹುದು , ಕಾಲಮ್ ಹೆಸರು ಅಥವಾ ಸೂಚಿಯನ್ನು ರವಾನಿಸುವುದು ಮತ್ತು ನವೀಕರಿಸಲು ಮೌಲ್ಯಗಳು. ನಾವು updateX ವಿಧಾನದಲ್ಲಿ X ಬದಲಿಗೆ ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಬಹುದು. ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ResultSet ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಿದ್ದೇವೆ. DB ಯಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು, ನಾವು updateRow() ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಬೇಕು.

ಸಾಲನ್ನು ಸೇರಿಸುವುದು:

ಕರ್ಸರ್ ಅನ್ನು ಸರಿಸಲು ನಾವು moveToInsertRow() ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಲು. ನಾವು ಈಗಾಗಲೇ ನ್ಯಾವಿಗೇಷನ್ ವಿಧಾನಗಳ ವಿಭಾಗದಲ್ಲಿ ಇದನ್ನು ಕವರ್ ಮಾಡಿದ್ದೇವೆ. ಮುಂದೆ, ಸಾಲಿಗೆ ಡೇಟಾವನ್ನು ಸೇರಿಸಲು ನಾವು updateX() ವಿಧಾನವನ್ನು ಕರೆಯಬೇಕಾಗಿದೆ. ನಾವು ಎಲ್ಲಾ ಕಾಲಮ್‌ಗಳಿಗೆ ಡೇಟಾವನ್ನು ಒದಗಿಸಬೇಕು ಇಲ್ಲದಿದ್ದರೆ ಅದು ನಿರ್ದಿಷ್ಟವಾದ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಬಳಸುತ್ತದೆಕಾಲಮ್.

ಡೇಟಾವನ್ನು ನವೀಕರಿಸಿದ ನಂತರ, ನಾವು insertRow() ವಿಧಾನವನ್ನು ಕರೆಯಬೇಕಾಗಿದೆ. ನಾವು ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ನಾವು ಇದ್ದ ಸಾಲಿಗೆ ಕರ್ಸರ್ ಸ್ಥಾನವನ್ನು ಹಿಂತಿರುಗಿಸಲು, moveToCurrentRow() ವಿಧಾನವನ್ನು ಬಳಸಿ.

ResultSet ಉದಾಹರಣೆ: 

package com.STH.JDBC; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class ResultSet_Example1 { public static void main(String[] args) throws ClassNotFoundException { // TODO Auto-generated method stub String select_query = "select empnum,lastName,firstName from employee_details"; String insert_query = "insert into employee_details values(?,?,?,?,?,?)"; Class.forName("oracle.jdbc.driver.OracleDriver"); //Connecting to Oracle DB try(Connection conn = DriverManager.getConnection("jdbc:oracle:thin:system/pass123@localhost:1521:XE")) { //Creating DatabaseMetaData object DatabaseMetaData dbmd = conn.getMetaData(); //Checking whether the driver supports scroll insensitive type and concur updatable boolean isSupportResultSetType = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); if(isSupportResultSetType == true) { // Creating prepared Statement PreparedStatement pstatemnt1 = conn.prepareStatement(select_query,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstatemnt1.executeQuery(select_query); //Moving the cursor to point last row of the table rs.last(); System.out.println("LAST ROW: Before inserting new Employee"); System.out.println("LAST ROW: EMPNUM = " + rs.getInt(1)); System.out.println("\n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); // Setting the values to insert in the EMPLOYEE_DETAILS Table //Moving the cursor to point insert a row to table rs.moveToInsertRow(); //Update EMPNUM value rs.updateInt(1, 1017); //Update LAST NAME value rs.updateString(2, "Bond"); //Update FIRST NAME value rs.updateString(3, "James"); //Insert a new row rs.insertRow(); //Moving the cursor to point 5th row rs.absolute(5); System.out.println("Befor Updating EMPNUM of the 5th ROW"); System.out.println("\n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); System.out.println(" Updating EMP id of the 5th EMPLOYEE"); //Updating EMPNUM of 5th row rs.updateInt(1,3005); rs.updateRow(); System.out.println("\n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); //Moving the cursor to point last row rs.last(); System.out.println("LAST ROW: EMPNUM = " + rs.getInt(1)); System.out.println("\n EMP NUM = " + rs.getInt("empNum") + "\n LAST NAME = "+ rs.getString(2)+"\n FIRST NAME = " + rs.getString(3)); } } catch (SQLException e) { e.printStackTrace(); } } }

ಔಟ್‌ಪುಟ್:

ವಿವರಣೆ:

ಮೇಲಿನ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾವು ಮಾಡಿದ್ದು ಮೊದಲನೆಯದು, ನಾವು ಸಂಗ್ರಹಿಸಿದ್ದೇವೆ SELECT ಪ್ರಶ್ನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ResultSet ವಸ್ತುವಿನಲ್ಲಿ Employee_details ಕೋಷ್ಟಕದ ಡೇಟಾ. ನಂತರ, ನಾವು ResultSet ನ ಕೊನೆಯ () ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಉದ್ಯೋಗಿ_ವಿವರಗಳ ಕೋಷ್ಟಕದಲ್ಲಿ ಕೊನೆಯ ಸಾಲಿನ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಿದ್ದೇವೆ. moveToInsertRow() ವಿಧಾನವು ಕರ್ಸರ್ ಅನ್ನು ಪ್ರಸ್ತುತ ಸಾಲನ್ನು ಸೂಚಿಸುವಂತೆ ಮಾಡುತ್ತದೆ, ಈಗ ಪ್ರಸ್ತುತ ಸಾಲು ಕೊನೆಯ ಸಾಲಾಗಿದೆ.

updateXXX() ವಿಧಾನಗಳನ್ನು ಸಾಲಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ನವೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು insertRow() ವಿಧಾನವು ಡೇಟಾವನ್ನು ಸೇರಿಸಿದೆ ಒಂದು ಹೊಸ ಸಾಲು. ಸಂಪೂರ್ಣ () ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಕರ್ಸರ್ ಅನ್ನು 5 ನೇ ಸಾಲಿಗೆ ಸೂಚಿಸುವಂತೆ ಮಾಡಿದ್ದೇವೆ. UpdateInt() ವಿಧಾನವನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ 5 ನೇ ಉದ್ಯೋಗಿಯ ಹೊಸ ಐಡಿಯೊಂದಿಗೆ EMPNUM ಅನ್ನು ನವೀಕರಿಸಲು ಬಳಸಲಾಗಿದೆ. ಅದರ ನಂತರ, EMPNUM ಅನ್ನು ನವೀಕರಿಸಲಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಕೊನೆಯ() ಅನ್ನು ಬಳಸಿಕೊಂಡು ಟೇಬಲ್‌ನ ಕೊನೆಯ ಸಾಲನ್ನು ಪಾಯಿಂಟ್ ಮಾಡಲು ಕರ್ಸರ್ ಅನ್ನು ಮಾಡಿದೆ ಮತ್ತು ಅದನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಮೇಲಿನ ತರ್ಕವನ್ನು ನಿರ್ವಹಿಸಲು, ನಾವು ಸಿದ್ಧಪಡಿಸುವ ಹೇಳಿಕೆ ವಿಧಾನದಲ್ಲಿ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ.

#4) ವಿವಿಧ ವಿಧಾನಗಳು

  • ಅನೂರ್ಜಿತ ಮುಚ್ಚು(): ಫಲಿತಾಂಶ ಸೆಟ್ ನಿದರ್ಶನವನ್ನು ಮುಚ್ಚಲು ಮತ್ತು ಮುಕ್ತಗೊಳಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆResultSet ನಿದರ್ಶನದೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಸಂಪನ್ಮೂಲಗಳು.
  • ResultSetMetaData getMetaData(): ಇದು ResultSetMetaData ನಿದರ್ಶನವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ಪ್ರಶ್ನೆ ಔಟ್‌ಪುಟ್‌ನ ಕಾಲಮ್‌ಗಳ ಪ್ರಕಾರ ಮತ್ತು ಆಸ್ತಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದೆ. ನಾವು ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ResultSetMetaData ಕುರಿತು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳುತ್ತೇವೆ.

ResultSetMetaData

ಮೆಟಾಡೇಟಾ ಎಂದರೇನು?

ಮೆಟಾಡೇಟಾ ಡೇಟಾದ ಬಗ್ಗೆ ಡೇಟಾ ಎಂದರ್ಥ. ಈ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ResultSet ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಇದು java.sql ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ. ಪ್ರತಿ ResultSet ಆಬ್ಜೆಕ್ಟ್ ಒಂದು ResultSetMetaData ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿದೆ.

ಈ ವಸ್ತುವು ಕಾಲಮ್‌ನ ಡೇಟಾ ಪ್ರಕಾರ, ಕಾಲಮ್ ಹೆಸರು, ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ, ಟೇಬಲ್ ಹೆಸರು, ಸ್ಕೀಮಾ ಹೆಸರು ಇತ್ಯಾದಿಗಳಂತಹ ಕಾಲಮ್‌ಗಳ ಗುಣಲಕ್ಷಣಗಳ ವಿವರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ResultSet ನ getMetaData() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ResultSetMetaData ವಸ್ತುವನ್ನು ಪಡೆಯಬಹುದು.

ResultSetMetaData ನ ಸಿಂಟ್ಯಾಕ್ಸ್: 

PreparedStatement pstatemnt1 = conn.prepareStatement(insert_query); ResultSet rs1 = pstatemnt1.executeQuery(“Select * from EMPLOYEE_DETAILS”); ResultSetMetaData rsmd = rs.getMetaData();

ResultSetMetaData ಇಂಟರ್ಫೇಸ್‌ನ ಪ್ರಮುಖ ವಿಧಾನಗಳು:

ವಿಧಾನದ ಹೆಸರು ವಿವರಣೆ
ಸ್ಟ್ರಿಂಗ್ getColumnName(int column) ಇದು ನಿರ್ದಿಷ್ಟ ಕಾಲಮ್‌ನ ಕಾಲಮ್ ಹೆಸರನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ getColumnTypeName(int column) ಇದು ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ನಿರ್ದಿಷ್ಟ ಕಾಲಮ್ ಅನ್ನು ನಾವು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ರವಾನಿಸಿದ್ದೇವೆ
ಸ್ಟ್ರಿಂಗ್ getTableName(int column) ಇದು ಕಾಲಮ್‌ನ ಟೇಬಲ್ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ getSchemaName(int column) ಇದು
ಮೇಲಕ್ಕೆ ಸ್ಕ್ರೋಲ್ ಮಾಡಿ