Wenn wir eine Liste von Datensätzen durch Abfragen abrufen, müssen wir sie oft in einem Objekt speichern, das ein Hin- und Her-Traversieren ermöglicht und bei Bedarf aktualisiert wird. Dieser Artikel veranschaulicht diese häufig benötigte Technik in der Datenbankprogrammierung mit expliziten Codes und Beispielszenarien.
Über ResultSet
Das ResultSet ist eine in java.sql definierte Schnittstelle Paket. Es stellt eine Tabelle mit Daten dar, die von einem Statement zurückgegeben werden Objekt. Eine Erklärung -Objekt wird verwendet, um SQL-Abfragen an die Datenbank auszuführen. Das ResultSet-Objekt verwaltet einen Cursor, der auf den aktuellen Datensatz in der Datenbanktabelle zeigt. Infolgedessen kann es effektiv verwendet werden, um mit first() hin und her in verschiedenen Zeilen zu positionieren , zurück() , weiter() , und last() Methoden nach Bedarf. Anfänglich das ResultSet Objekt wird an einer Stelle vor der ersten Zeile positioniert. Das ist der Grund für ein ResultSet Die Traversierung beginnt immer wie folgt:
while(resultSet.next()) {
// ...
}
Beachten Sie, dass das ResultSet Objekt wird in der ersten Zeile positioniert, indem next() ausgeführt wird Methode beim Eintritt in die Schleife, da, wie bereits erwähnt, das ResultSet Das Objekt befindet sich zunächst an einer Position kurz vor der ersten Zeile. Es muss also beispielsweise mindestens in die erste Zeile gestellt werden, um einen gültigen Datensatz zu erhalten. Es kann als Wert -1 in einer Array-Position angesehen werden, auf die ein Zeiger/Index zeigt. Es muss zuerst mindestens an die Position 0 verschoben werden, um einen gültigen Wert aus dem Array zu erhalten.
Nun können wir, wie bereits erwähnt, mit Hilfe des ResultSet durch Datensätze scrollen Objekt. Diese Fähigkeit ist jedoch nicht standardmäßig verfügbar. Das Standardverhalten des ResultSet Das Objekt ist, dass es nicht aktualisierbar ist und der Cursor, den es besitzt, sich tatsächlich in eine Richtung bewegt, nur vorwärts. Dies bedeutet, dass wir die Datensätze nur einmal und nur in Vorwärtsrichtung durchlaufen können. Es gibt jedoch Möglichkeiten, es flexibel zu gestalten, sodass das ResultSet ist nicht nur aktualisierbar, sondern auch scrollbar.
Wir werden sie in einer Minute in zwei separaten Sendungen sehen.
Scrollbarer Ergebnissatz
Lassen Sie uns zuerst das ResultSet erstellen Objekt scrollbar. Scrollbar bedeutet, dass einmal das ResultSet Objekt erstellt wurde, können wir die abgerufenen Datensätze in jeder beliebigen Richtung durchlaufen, vorwärts und rückwärts, wie wir möchten. Dies bietet die Möglichkeit, den letzten Datensatz, den ersten Datensatz, den nächsten Datensatz und den vorherigen Datensatz zu lesen.
package org.mano.example;
import java.sql.*;
public class App
{
static final String JDBC_DRIVER =
"com.mysql.cj.jdbc.Driver";
static final String DB_URL =
"jdbc:mysql://localhost:3306/employees";
static final String USER = "root";
static final String PASS = "secret";
static final String SQL =
"SELECT * FROM employees ORDER BY first_name";
public static void main( String[] args )
{
Connection connection = null;
ResultSet rs = null;
try {
Class.forName(JDBC_DRIVER);
connection = DriverManager.getConnection
(DB_URL, USER, PASS);
System.out.println("n1. Connection established");
}catch(Exception ex) {
ex.printStackTrace();
}
try (PreparedStatement pstmt =
connection.prepareStatement(SQL,
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);){
System.out.println("n2.
Executing SQL query...");
rs = pstmt.executeQuery();
System.out.println("n3.
ResultSet object created successfully.");
System.out.println("n4.
Now some RecordSet scrolling starts...");
rs.first();
show(rs);
rs.last();
show(rs);
rs.previous();
rs.previous();
show(rs);
rs.next();
show(rs);
System.out.println("nn5. That's all.
RecordSet scrolling ends.");
}catch(SQLException ex){
ex.printStackTrace();
}finally{
try {
connection.close();
}catch(SQLException ex){
}
}
}
public static void show(ResultSet rs) throws
SQLException{
System.out.printf
("n--------------------------------"+
"-------------------------------------");
System.out.printf("n%7d | %10s | %10s | %s
| %s | %s ",rs.getLong("emp_no"),
rs.getString("first_name"),
rs.getString("last_name"),
rs.getDate("birth_date").toString(),
rs.getDate("hire_date"),
rs.getString("gender"));
System.out.printf
("n---------------------------------"+
"------------------------------------");
}
}
Ausgabe
- Verbindung hergestellt.
- SQL-Abfrage wird ausgeführt…
- ResultSet-Objekt erfolgreich erstellt.
- Nun beginnt etwas RecordSet-Scrolling…
------------------------------------------------------------- 497615 | Aamer | McDermid | 1954-11-18 | 1985-04-24 | M ------------------------------------------------------------- ------------------------------------------------------------- 484995 | Zvonko | Lakshmanan | 1964-11-04 | 1992-12-04 | M ------------------------------------------------------------- ------------------------------------------------------------- 482000 | Zvonko | Cannata | 1960-11-23 | 1986-08-13 | M ------------------------------------------------------------- ------------------------------------------------------------- 483497 | Zvonko | Pollacia | 1961-12-26 | 1985-08-01 | M -------------------------------------------------------------
- Das ist alles. RecordSet-Scrolling endet.
Beachten Sie, dass das scrollbare ResultSet Objekt ist das Ergebnis der Ausführung von executeQuery() Methode, die durch die Instanz von Statement erhalten wird oder PreparedStatement . Der Typ von ResultSet Objekt, das wir erstellen möchten, muss explizit im Statement deklariert werden Objekt durch definierte Bildlaufkonstanten.
- Ergebnissatz.TYPE_FORWARD_ONLY: Dies ist der Standardtyp.
- Ergebnissatz.TYPE_SCROLL_INSENSITIVE: Ermöglicht die Hin- und Herbewegung, ist aber unempfindlich gegenüber ResultSet Aktualisierungen.
- Ergebnissatz.TYPE_SCROLL_SENSITIVE: Ermöglicht Hin- und Herbewegungen, reagiert jedoch empfindlich auf ResultSet Aktualisierungen.
Es werden andere Konstanten verwendet, wie zum Beispiel CONCUR_READ_ONLY , was bedeutet, dass das ResultSet ist nicht aktualisierbar. Es gibt eine weitere Konstante, CONCUR_UPDATABLE , was das Gegenteil bedeutet, also das ResultSet ist aktualisierbar.
Aktualisierbares ResultSet
Erstellen eines aktualisierbaren ResultSet bedeutet, dass der Datensatz, auf den es zeigt, nicht nur passierbar, sondern auch aktualisierbar ist. Die Änderungen werden sofort in der Datenbank gespeichert und vom ResultSet widergespiegelt Objekt in Echtzeit.
package org.mano.example;
import java.sql.*;
public class App
{
static final String JDBC_DRIVER =
"com.mysql.cj.jdbc.Driver";
static final String DB_URL =
"jdbc:mysql://localhost:3306/employees";
static final String USER = "root";
static final String PASS = "secret";
static final String SQL =
"SELECT * FROM employees WHERE emp_no = ?";
public static void main( String[] args )
{
Connection connection = null;
ResultSet rs = null;
long emp_no = 484995;
try {
Class.forName(JDBC_DRIVER);
connection = DriverManager.getConnection
(DB_URL, USER, PASS);
System.out.println("n1.
Connection established");
}catch(Exception ex) {
ex.printStackTrace();
}
try(PreparedStatement pstmt =
connection.prepareStatement(SQL,
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);){
pstmt.setLong(1,emp_no);
System.out.println("n2.
Executing SQL query...");
rs = pstmt.executeQuery();
System.out.println("n3.
ResultSet object created successfully.");
while(rs.next()){
show(rs);
String fname = rs.getString("first_name");
System.out.println("n4.
Updating name "+fname+" to Subham");
rs.updateString("first_name", "Subham");
rs.updateRow();
}
System.out.println("nn5.
Record updated. See below.");
rs.previous();
show(rs);
}catch(SQLException ex){
ex.printStackTrace();
}finally{
try {
rs.close();
connection.close();
}catch(SQLException ex){
}
}
}
public static void show(ResultSet rs)
throwsSQLException{
System.out.printf
("n--------------------------------"+
"-------------------------------------");
System.out.printf("n%7d | %10s | %10s | %s
| %s | %s ",rs.getLong("emp_no"),
rs.getString("first_name"),
rs.getString("last_name"),
rs.getDate("birth_date").toString(),
rs.getDate("hire_date"),
rs.getString("gender"));
System.out.printf
("n---------------------------------"+
"------------------------------------");
}
}
Das aktualisierbare ResultSet ist besonders nützlich, wenn wir bestimmte Werte aktualisieren möchten, nachdem wir einige Vergleiche durchgeführt haben, indem wir die abgerufenen Datensätze vor und zurück durchlaufen. Der Erstellungsprozess ist ähnlich wie beim vorherigen Programm, aber das ResultSet hier verwendete Konstanten sind TYPE_SCROLL_SENSITIVE und CONCUR_UPDATABLE .
Schlussfolgerung
Entgegen dem Standardverhalten des ResultSet, es befähigt das Objekt, eine größere Flexibilität zu haben. Diese Funktionalität kann von der Anwendung genutzt werden, um Datensätze nicht nur zu durchlaufen, sondern sie auch aktualisierbar zu machen, damit sie einen besseren Service bieten können. Obwohl das Standardverhalten eines Ergebnissatzes im Vergleich zum scrollbaren ResultSet ziemlich ineffizient erscheint , es hat seinen eigenen Nutzen und ist daher unersetzlich.
