Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of mappen te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen om mappen te wijzigen.
JDBC-stuurprogramma downloaden
Dit Microsoft JDBC-stuurprogramma voor sql Server-voorbeeldtoepassing laat zien hoe u een grote set gegevens ophaalt uit een database. Vervolgens wordt het aantal rijen met gegevens die in de cache op de client zijn opgeslagen, bepaald met behulp van de methode setFetchSize van het OBJECT SQLServerResultSet .
Opmerking
Het beperken van het aantal rijen dat op de client in de cache is opgeslagen, verschilt van het beperken van het totale aantal rijen dat een resultatenset kan bevatten. Als u het totale aantal rijen in een resultatenset wilt beheren, gebruikt u de methode setMaxRows van het OBJECT SQLServerStatement , die wordt overgenomen door zowel de objecten SQLServerPreparedStatement alsSQLServerCallableStatement .
Als u een limiet wilt instellen voor het aantal rijen in de cache op de client, geeft u een cursortype op dat gebruikmaakt van een cursor aan de serverzijde bij het maken van instructieobjecten. Het JDBC-stuurprogramma biedt bijvoorbeeld het TYPE_SS_SERVER_CURSOR_FORWARD_ONLY-cursortype, een snelle, vooruit-alleen-lezen cursor aan de serverzijde voor gebruik met SQL Server-databases.
Opmerking
Een alternatief voor het gebruik van het sql Server-specifieke cursortype is het gebruik van de eigenschap selectMethod-verbindingsreeks, waarbij de waarde wordt ingesteld op 'cursor'. Voor meer informatie over de cursortypen die worden ondersteund door het JDBC-stuurprogramma, zie Inzicht in cursortypen.
Nadat u de query in het instructieobject hebt uitgevoerd en de gegevens als resultaatset naar de client worden geretourneerd, roept setFetchSize u aan om te bepalen hoeveel gegevens er tegelijk uit de database worden opgehaald. Als u bijvoorbeeld een tabel met 100 rijen gegevens hebt en de ophaalgrootte 10 is, worden er slechts 10 rijen met gegevens tegelijk in de cache opgeslagen op de client. Hoewel deze instelling de snelheid kan vertragen waarmee de gegevens worden verwerkt, gebruikt deze minder geheugen op de client. Dit scenario is handig wanneer u grote hoeveelheden gegevens moet verwerken zonder te veel geheugen te gebruiken.
Het codebestand voor dit voorbeeld heeft de naam CacheResultSet.java en kan worden gevonden op de volgende locatie:
\<installation directory>\sqljdbc_<version>\<language>\samples\resultsets
Requirements
Als u deze voorbeeldtoepassing wilt uitvoeren, stelt u het classpath in om het mssql-jdbc jar-bestand op te nemen. U hebt ook toegang nodig tot de voorbeelddatabase AdventureWorks2025. Zie Het JDBC-stuurprogramma gebruiken voor meer informatie over het instellen van het klassepad.
Opmerking
Het Microsoft JDBC-stuurprogramma voor SQL Server biedt mssql-jdbc-klassebibliotheekbestanden die gebruikt kunnen worden, op basis van de instellingen voor de Java Runtime Environment (JRE). Zie Systeemvereisten voor het JDBC-stuurprogramma voor meer informatie over welk JAR-bestand u wilt kiezen.
Example
In het volgende voorbeeld maakt de voorbeeldcode een verbinding met de AdventureWorks2025-voorbeelddatabase. Vervolgens wordt een SQL-instructie gebruikt met het SQLServerStatement-object , wordt het cursortype aan de serverzijde opgegeven en wordt de SQL-instructie uitgevoerd. De gegevens worden geretourneerd in een SQLServerResultSet-object.
Vervolgens roept de voorbeeldcode de aangepaste timerTest-methode aan en geeft daarbij de te gebruiken ophaalgrootte en de resultatenset als argumenten door. De timerTest-methode stelt vervolgens de ophaalgrootte van de resultatenset in met behulp van de methode setFetchSize, stelt de begintijd van de test in en doorloopt vervolgens de resultatenset met een While lus. Zodra de While lus is afgesloten, stelt de code de stoptijd van de test in en wordt het resultaat van de test weergegeven, inclusief de ophaalgrootte, het aantal verwerkte rijen en de tijd die nodig was om de test uit te voeren.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import com.microsoft.sqlserver.jdbc.SQLServerResultSet;
public class CacheResultSet {
@SuppressWarnings("serial")
public static void main(String[] args) {
// Create a variable for the connection string.
String connectionUrl = "jdbc:sqlserver://<server>:<port>;encrypt=true;databaseName=AdventureWorks;user=<user>;password=<password>";
try (Connection con = DriverManager.getConnection(connectionUrl);
Statement stmt = con.createStatement(SQLServerResultSet.TYPE_SS_SERVER_CURSOR_FORWARD_ONLY, SQLServerResultSet.CONCUR_READ_ONLY);) {
String SQL = "SELECT * FROM Sales.SalesOrderDetail;";
for (int n : new ArrayList<Integer>() {
{
add(1);
add(10);
add(100);
add(1000);
add(0);
}
}) {
// Perform a fetch for every nth row in the result set.
try (ResultSet rs = stmt.executeQuery(SQL)) {
timerTest(n, rs);
}
}
}
// Handle any errors that may have occurred.
catch (SQLException e) {
e.printStackTrace();
}
}
private static void timerTest(int fetchSize,
ResultSet rs) throws SQLException {
// Declare the variables for tracking the row count and elapsed time.
int rowCount = 0;
long startTime = 0;
long stopTime = 0;
long runTime = 0;
// Set the fetch size then iterate through the result set to
// cache the data locally.
rs.setFetchSize(fetchSize);
startTime = System.currentTimeMillis();
while (rs.next()) {
rowCount++;
}
stopTime = System.currentTimeMillis();
runTime = stopTime - startTime;
// Display the results of the timer test.
System.out.println("FETCH SIZE: " + rs.getFetchSize());
System.out.println("ROWS PROCESSED: " + rowCount);
System.out.println("TIME TO EXECUTE: " + runTime);
System.out.println();
}
}