Appel de fonctions SQL Server

CallableStatement

JDBC a une autre interface pour des scénarios encore plus complexes. Il hérite de PreparedStatement et s'appelle CallableStatement .

Il est utilisé pour appeler (Call) des procédures stockées dans la base de données. La particularité d'un tel appel est que, en plus du ResultSet result , des paramètres peuvent également être passés à une telle procédure stockée.

Quoi de neuf, demandez-vous ? PreparedStatement a également un résultat ResultSet et vous pouvez également lui transmettre des paramètres. Oui, c'est vrai, mais la particularité des procédures stockées est que, grâce à des paramètres, elles peuvent non seulement recevoir, mais également renvoyer des données.

La procédure stockée est appelée avec les paramètres IN , OUT et INOUT . Elle renvoie un ou plusieurs objets ResultSet . La méthode Connection.prepareCall() est utilisée pour créer un objet CallableStatement .

Imaginez ici que vous avez une procédure stockée ADD qui accepte les paramètres a, b et c. Cette procédure additionne a et b et place le résultat de l'addition dans la variable c.

Écrivons le code où nous essaierons de l'appeler:

// Connect to the server
Connection connection = DriverManager.getConnection("jdbc:as400://mySystem");

// Create a CallableStatement object. It does preprocessing
// calling a stored procedure. Question marks
// indicate where the input parameters should be substituted, and where the output ones
// The first two parameters are input,
// and the third one is a day off.
CallableStatement statement = connection.prepareCall("CALL MYLIBRARY.ADD (?, ?, ?)");

// Setting up input parameters. Passing 123 and 234 to the procedure
statement.setInt (1, 123);
statement.setInt (2, 234);

// Registering the output parameter type
statement.registerOutParameter (3, Types.INTEGER);

// Run stored procedure
statement.execute();

// Get the value of the output parameter
int sum = statement.getInt(3);

// Close CallableStatement and Connection
statement.close();
connection.close();

Le travail est presque comme avec PreparedStatement , sauf qu'il y a une nuance. Notre fonction ADD renvoie le résultat de l'addition dans le troisième paramètre. Seul l' objet CallableStatement n'en sait rien. Par conséquent, nous lui disons cela explicitement en appelant la méthode registerOutParameter() :

registerOutParameter(parameter number, Parameter type)

Après cela, vous pouvez appeler la procédure via la méthode execute() , puis lire les données du troisième paramètre à l'aide de la méthode getInt() .

Demandes groupées

Dans les projets réels, une situation se présente souvent lorsque vous devez effectuer un grand nombre de requêtes du même type (la plus courante dans ce cas est PreparedStatement ), par exemple, vous devez insérer plusieurs dizaines ou centaines d'enregistrements.

Si vous exécutez chaque requête séparément, cela prendra beaucoup de temps et réduira les performances de l'application. Pour éviter cela, vous pouvez utiliser le mode d'insertion par lot. Cela réside dans le fait que vous accumulez un tampon avec vos requêtes, puis que vous les exécutez immédiatement.

Voici un bout de code à titre d'exemple :

PreparedStatement stmt = con.prepareStatement(
        	"INSERT INTO jc_contact (first_name, last_name, phone, email) VALUES (?, ?, ?, ?)");

for (int i = 0; i < 10; i++) {
	// Fill in the request parameters
	stmt.setString(1, "FirstName_" + i);
    stmt.setString(2, "LastNAme_" + i);
    stmt.setString(3, "phone_" + i);
    stmt.setString(4, "email_" + i);
	// The request is not executed, but fits into the buffer,
	// which is then executed immediately for all commands
	stmt.addBatch();
}
// Execute all requests at once
int[] results = stmt.executeBatch();

Au lieu d'exécuter la requête avec la méthode execute() , nous la regroupons avec la méthode addBatch() .

Et puis, lorsqu'il y a plusieurs centaines de requêtes, vous pouvez toutes les envoyer d'un coup au serveur en appelant la commande executeBatch() .

En bonne santé. La méthode executeBatch() renvoie un tableau d'entiers — int[]. Chaque cellule de ce tableau contient un nombre qui indique le nombre de lignes modifiées par la requête correspondante. Si la demande numéro 3 dans le lot a changé 5 lignes, la 3ème cellule du tableau contiendra le numéro 5.