L'auteur de cet article explique comment appeler les procédures stockées de SQL Server via Java et explique en détail cinq types de stockage différents. Veuillez voir ci-dessous pour plus de détails
1. Utilisez une procédure stockée sans paramètres
Lorsque vous utilisez un pilote JDBC pour appeler une procédure stockée sans paramètres, vous devez utiliser la séquence d'échappement SQL d'appel. La syntaxe de la séquence d'échappement d'appel sans paramètres est la suivante :
Copiez le code comme suit :
{nom-procédure d'appel}
À titre d'exemple, créez la procédure stockée suivante dans l'exemple de base de données SQL Server 2005 AdventureWorks :
Copiez le code comme suit :
CRÉER UNE PROCÉDURE GetContactFormalNames
COMME
COMMENCER
SELECT TOP 10 Titre + ' ' + Prénom + ' ' + Nom AS FormalName
DE Personne.Contact
FIN
Cette procédure stockée renvoie un jeu de résultats unique contenant une colonne de données composée du titre, du prénom et du nom des dix premiers contacts de la table Person.Contact.
Dans l'exemple suivant, cette fonction reçoit une connexion ouverte à l'exemple de base de données AdventureWorks, puis la procédure stockée GetContactFormalNames est appelée à l'aide de la méthodeexecuteQuery.
Copiez le code comme suit :
public static void executeSprocNoParams(Connection con) ...{
essayer...{
Instruction stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("{call dbo.GetContactFormalNames}");
tandis que (rs.next()) ...{
System.out.println(rs.getString("FormalName"));
}
rs.close();
stmt.close();
}
attraper (Exception e) ...{
e.printStackTrace();
}
}
2. Utilisez une procédure stockée avec des paramètres d'entrée
Lorsque vous utilisez un pilote JDBC pour appeler une procédure stockée avec des paramètres, vous devez utiliser la séquence d'échappement call SQL conjointement avec la méthode prepareCall de la classe SQLServerConnection. La syntaxe d'une séquence d'échappement d'appel avec un paramètre IN est la suivante :
Copiez le code comme suit :
{nom-procédure d'appel[([paramètre][,[paramètre]]...)]}
Lors de la construction d'une séquence d'échappement d'appel, utilisez le caractère ? (point d'interrogation) pour spécifier le paramètre IN. Ce caractère sert d'espace réservé pour la valeur du paramètre à transmettre à la procédure stockée. Vous pouvez utiliser l'une des méthodes setter de la classe SQLServerPreparedStatement pour spécifier les valeurs des paramètres. Les méthodes de définition disponibles sont déterminées par le type de données du paramètre IN.
Lorsque vous transmettez une valeur à une méthode setter, vous devez spécifier non seulement la valeur réelle à utiliser dans le paramètre, mais également la position ordinale du paramètre dans la procédure stockée. Par exemple, si une procédure stockée contient un seul paramètre IN, sa valeur ordinale est 1. Si la procédure stockée contient deux paramètres, la première valeur ordinale est 1 et la deuxième valeur ordinale est 2.
Comme exemple d'appel d'une procédure stockée contenant un paramètre IN, utilisez la procédure stockée uspGetEmployeeManagers dans l'exemple de base de données SQL Server 2005 AdventureWorks. Cette procédure stockée accepte un seul paramètre d'entrée nommé EmployeeID, qui est une valeur entière, et renvoie une liste récursive des employés et de leurs responsables en fonction de l'EmployeeID spécifié. Voici le code Java qui appelle cette procédure stockée :
Copiez le code comme suit :
public static void executeSprocInParams(Connection con) ...{
essayer...{
PreparedStatement pstmt = con.prepareStatement("{call dbo.uspGetEmployeeManagers(?)}");
pstmt.setInt(1, 50);
ResultSet rs = pstmt.executeQuery();
tandis que (rs.next()) ...{
System.out.println("EMPLOYÉ :");
System.out.println(rs.getString("LastName") + ", " + rs.getString("FirstName"));
System.out.println("MANAGER:");
System.out.println(rs.getString("ManagerLastName") + ", " + rs.getString("ManagerFirstName"));
System.out.println();
}
rs.close();
pstmt.close();
}
attraper (Exception e) ...{
e.printStackTrace();
}
}
3. Utilisez une procédure stockée avec des paramètres de sortie
Lorsque vous appelez de telles procédures stockées à l'aide d'un pilote JDBC, vous devez utiliser la séquence d'échappement call SQL conjointement avec la méthode prepareCall de la classe SQLServerConnection. La syntaxe d'une séquence d'échappement d'appel avec un paramètre OUT est la suivante :
Copiez le code comme suit :
{nom-procédure d'appel[([paramètre][,[paramètre]]...)]}
Lors de la construction d'une séquence d'échappement d'appel, utilisez le caractère ? (point d'interrogation) pour spécifier le paramètre OUT. Ce caractère sert d'espace réservé pour la valeur du paramètre à renvoyer à partir de cette procédure stockée. Pour spécifier des valeurs pour les paramètres OUT, vous devez utiliser la méthode registerOutParameter de la classe SQLServerCallableStatement pour spécifier le type de données de chaque paramètre avant d'exécuter la procédure stockée.
La valeur spécifiée pour le paramètre OUT à l'aide de la méthode registerOutParameter doit être l'un des types de données JDBC contenus dans java.sql.Types, qui à son tour est mappé à l'un des types de données natifs de SQL Server. Pour plus d'informations sur les types de données JDBC et SQL Server, consultez Présentation des types de données du pilote JDBC.
Lorsque vous transmettez une valeur à la méthode registerOutParameter pour un paramètre OUT, vous devez non seulement spécifier le type de données à utiliser pour le paramètre, mais vous devez également spécifier la position ordinale du paramètre ou le nom du paramètre dans la procédure stockée. Par exemple, si une procédure stockée contient un seul paramètre OUT, sa valeur ordinale est 1 ; si une procédure stockée contient deux paramètres, la première valeur ordinale est 1 et la deuxième valeur ordinale est 2.
À titre d'exemple, créez la procédure stockée suivante dans l'exemple de base de données SQL Server 2005 AdventureWorks : En fonction du paramètre IN entier spécifié (employeeID), cette procédure stockée renvoie également un seul paramètre OUT entier (managerID). Sur la base du EmployeeID contenu dans la table HumanResources.Employee, la valeur renvoyée dans le paramètre OUT est ManagerID.
Dans l'exemple suivant, cette fonction reçoit une connexion ouverte à l'exemple de base de données AdventureWorks, puis la procédure stockée GetImmediateManager est appelée à l'aide de la méthode d'exécution :
Copiez le code comme suit :
public static voidexecuteStoredProcedure(Connection con) ...{
essayer...{
CallableStatement cstmt = con.prepareCall("{call dbo.GetImmediateManager(?, ?)}");
cstmt.setInt(1, 5);
cstmt.registerOutParameter(2, java.sql.Types.INTEGER);
cstmt.execute();
System.out.println("ID DU MANAGER : " + cstmt.getInt(2));
}
attraper (Exception e) ...{
e.printStackTrace();
}
}
Cet exemple utilise la position ordinale pour identifier les paramètres. Alternativement, le paramètre peut être identifié par son nom plutôt que par sa position ordinale. L'exemple de code suivant modifie l'exemple précédent pour illustrer comment utiliser des paramètres nommés dans une application Java. Notez que ces noms de paramètres correspondent aux noms de paramètres dans la définition de la procédure stockée : 11x16CREATE PROCEDURE GetImmediateManager
Copiez le code comme suit :
@employeeID INT,
@managerID INT SORTIE
COMME
COMMENCER
SELECT @managerID = ManagerID
DE HumanResources.Employé
OERE EmployeeID = @employeeID
FIN
Les procédures stockées peuvent renvoyer des nombres de mises à jour et plusieurs jeux de résultats. Le pilote JDBC Microsoft SQL Server 2005 est conforme à la spécification JDBC 3.0, qui stipule que plusieurs jeux de résultats et décomptes de mises à jour doivent être récupérés avant de récupérer les paramètres OUT. Autrement dit, l'application doit d'abord récupérer tous les objets ResultSet et mettre à jour le nombre, puis utiliser la méthode CallableStatement.getter pour récupérer les paramètres OUT. Sinon, lorsque le paramètre OUT est récupéré, l'objet ResultSet et le nombre de mises à jour qui n'ont pas encore été récupérés seront perdus.
4. Utilisez des procédures stockées avec le statut de retour
Lorsque vous appelez une telle procédure stockée à l'aide d'un pilote JDBC, vous devez utiliser la séquence d'échappement call SQL en conjonction avec la méthode prepareCall de la classe SQLServerConnection. La syntaxe d'une séquence d'échappement d'appel qui renvoie un paramètre d'état est la suivante :
Copiez le code comme suit :
{[?=]appeler nom-procédure[([paramètre][,[paramètre]]...)]}
Lors de la construction d'une séquence d'échappement d'appel, utilisez le caractère ? (point d'interrogation) pour spécifier le paramètre d'état de retour. Ce caractère sert d'espace réservé pour la valeur du paramètre à renvoyer à partir de cette procédure stockée. Pour spécifier une valeur pour un paramètre d'état de retour, vous devez spécifier le type de données du paramètre à l'aide de la méthode registerOutParameter de la classe SQLServerCallableStatement avant d'exécuter la procédure stockée.
De plus, lorsque vous transmettez la valeur du paramètre d'état de retour à la méthode registerOutParameter, vous devez spécifier non seulement le type de données du paramètre à utiliser, mais également la position ordinale du paramètre dans la procédure stockée. La position ordinale du paramètre d'état de retour est toujours 1 car il s'agit toujours du premier paramètre lorsque la procédure stockée est appelée. Bien que la classe SQLServerCallableStatement prenne en charge l'utilisation du nom du paramètre pour indiquer un paramètre spécifique, vous pouvez uniquement utiliser le numéro de position ordinale du paramètre pour les paramètres d'état de retour.
À titre d'exemple, créez la procédure stockée suivante dans l'exemple de base de données SQL Server 2005 AdventureWorks :
Copiez le code comme suit :
CRÉER UNE PROCÉDURE CheckContactCity
(@cityName CHAR(50))
COMME
COMMENCER
SI ((SÉLECTIONNER LE COMPTE(*)
DE Personne.Adresse
OÙ Ville = @cityName) > 1)
RETOUR 1
AUTRE
RETOUR 0
FIN
La procédure stockée renvoie une valeur d'état de 1 ou 0, selon que la ville spécifiée par le paramètre cityName se trouve dans la table Person.Address.
Dans l'exemple suivant, cette fonction reçoit une connexion ouverte à l'exemple de base de données AdventureWorks, puis la procédure stockée CheckContactCity est appelée à l'aide de la méthode d'exécution :
Copiez le code comme suit :
public static voidexecuteStoredProcedure(Connection con) ...{
essayer...{
CallableStatement cstmt = con.prepareCall("{? = appeler dbo.CheckContactCity(?)}");
cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
cstmt.setString(2, "Atlanta");
cstmt.execute();
System.out.println("STATUT DE RETOUR : " + cstmt.getInt(1));
}
cstmt.close();
attraper (Exception e) ...{
e.printStackTrace();
}
}
5. Utilisez une procédure stockée avec un nombre de mises à jour
Après avoir utilisé la classe SQLServerCallableStatement pour construire un appel à une procédure stockée, vous pouvez utiliser les méthodesexecute ouexecuteUpdate pour appeler la procédure stockée. La méthodeexecuteUpdate renvoie une valeur int contenant le nombre de lignes affectées par cette procédure stockée, mais la méthodeexecute ne renvoie pas cette valeur. Si vous utilisez la méthode d'exécution et souhaitez obtenir le nombre de lignes affectées, vous pouvez appeler la méthode getUpdateCount après avoir exécuté la procédure stockée.
À titre d'exemple, créez les tables et procédures stockées suivantes dans l'exemple de base de données SQL Server 2005 AdventureWorks :
Copiez le code comme suit :
CRÉER UNE TABLETestTable
(Col1 int IDENTITÉ,
Col2 varchar(50),
Col3 int);
CRÉER UNE PROCÉDURE
@Col2varchar(50),
@Col3 entier
COMME
COMMENCER
MISE À JOUR de la table de test
SET Col2 = @Col2, Col3 = @Col3
FIN;
Dans l'exemple suivant, cette fonction reçoit une connexion ouverte à l'exemple de base de données AdventureWorks, utilise la méthode d'exécution pour appeler la procédure stockée UpdateTestTable, puis utilise la méthode getUpdateCount pour renvoyer le nombre de lignes affectées par la procédure stockée.
Copiez le code comme suit :
public static void executeUpdateStoredProcedure(Connection con) ...{
essayer...{
CallableStatement cstmt = con.prepareCall("{call dbo.UpdateTestTable(?, ?)}");
cstmt.setString(1, "A");
cstmt.setInt(2, 100);
cstmt.execute();
int count = cstmt.getUpdateCount();
cstmt.close();
System.out.println("LIGNES AFFECTÉES : " + nombre);
}
attraper (Exception e) ...{
e.printStackTrace();