Appel d’une procédure stockée (OLE DB)

Une procédure stockée peut avoir zéro ou plusieurs paramètres. Elle peut également retourner une valeur. Lorsque vous utilisez le fournisseur OLE DB SQL Server Native Client, les paramètres d’une procédure stockée peuvent être passés par :

• Codage en dur de la valeur des données.

• À l’aide d’un marqueur de paramètre ( ?) pour spécifier des paramètres, liez une variable de programme au marqueur de paramètre, puis placez la valeur de données dans la variable de programme.

Pour prendre en charge les paramètres, l’interface ICommandWithParameters est exposée sur l’objet de commande. Pour utiliser des paramètres, le consommateur décrit d’abord les paramètres au fournisseur en appelant la méthode ICommandWithParameters ::SetParameterInfo (ou prépare éventuellement une instruction appelante qui appelle la méthode GetParameterInfo ). Le consommateur crée ensuite un accesseur qui spécifie la structure d’une mémoire tampon et place les valeurs de paramètre dans cette mémoire tampon. Enfin, il transmet le handle de l’accesseur et un pointeur vers la mémoire tampon à Exécuter. Lors des appels ultérieurs à Execute, le consommateur place de nouvelles valeurs de paramètre dans la mémoire tampon et appelle Execute avec le handle d’accesseur et le pointeur de mémoire tampon.

Une commande qui appelle une procédure stockée temporaire à l’aide de paramètres doit d’abord appeler ICommandWithParameters ::SetParameterInfo pour définir les informations de paramètre, avant que la commande puisse être préparée. Cela est dû au fait que le nom interne d’une procédure stockée temporaire diffère du nom externe utilisé par un client et SQLOLEDB ne peut pas interroger les tables système pour déterminer les informations de paramètre d’une procédure stockée temporaire.

Voici les étapes du processus de liaison de paramètre :

1. Renseignez les informations de paramètre dans un tableau de structures DBPARAMBINDINFO ; autrement dit, le nom du paramètre, le nom spécifique au fournisseur pour le type de données du paramètre ou un nom de type de données standard, et ainsi de suite. Chaque structure du tableau décrit un paramètre. Ce tableau est ensuite passé à la méthode SetParameterInfo .

2. Appelez la méthode ICommandWithParameters ::SetParameterInfo pour décrire les paramètres au fournisseur. SetParameterInfo spécifie le type de données natif de chaque paramètre. Les arguments SetParameterInfo sont les suivants :

   • Nombre de paramètres pour lesquels définir les informations de type.

   • Tableau d’ordinals de paramètres pour lesquels définir des informations de type.

   • Tableau de structures DBPARAMBINDINFO.

3. Créez un accesseur de paramètre à l’aide de la commande IAccessor ::CreateAccessor . L’accesseur spécifie la structure d’une mémoire tampon et place les valeurs des paramètres dans la mémoire tampon. La commande CreateAccessor crée un accesseur à partir d’un ensemble de liaisons. Ces liaisons sont décrites par le consommateur à l’aide d’un tableau de structures DBBINDING. Chaque liaison associe un seul paramètre à la mémoire tampon du consommateur et contient des informations telles que :

   • ordinal du paramètre auquel la liaison s’applique.

   • Qu’est-ce qui est lié (valeur de données, sa longueur et son état).

   • Décalage dans la mémoire tampon pour chacune de ces parties.

   • Longueur et type de la valeur de données telle qu’elle existe dans la mémoire tampon du consommateur.

   Un accesseur est identifié par son handle, qui est de type HACCESSOR. Ce handle est retourné par la méthode CreateAccessor . Chaque fois que le consommateur se termine à l’aide d’un accesseur, le consommateur doit appeler la méthode ReleaseAccessor pour libérer la mémoire qu’il contient.

   Lorsque le consommateur appelle une méthode, telle que ICommand ::Execute, elle transmet le handle à un accesseur et un pointeur vers une mémoire tampon elle-même. Le fournisseur utilise cet accesseur pour déterminer comment transférer les données contenues dans la mémoire tampon.

4. Renseignez la structure DBPARAMS. Les variables de consommateur à partir desquelles les valeurs de paramètre d’entrée sont prises et vers lesquelles les valeurs de paramètre de sortie sont écrites sont passées au moment de l’exécution à ICommand ::Execute dans la structure DBPARAMS. La structure DBPARAMS comprend trois éléments :

   • Pointeur vers la mémoire tampon à partir de laquelle le fournisseur récupère les données de paramètre d’entrée et vers laquelle le fournisseur retourne des données de paramètre de sortie, en fonction des liaisons spécifiées par le handle d’accesseur.

   • Nombre de jeux de paramètres dans la mémoire tampon.

   • Handle d’accesseur créé à l’étape 3.

5. Exécutez la commande à l’aide de ICommand ::Execute.

Méthodes d’appel d’une procédure stockée

Lors de l’exécution d’une procédure stockée dans SQL Server, le fournisseur OLE DB SQL Server Native Client prend en charge les points suivants :

• Séquence d’échappement ODBC CALL.

• Séquence d’échappement d’appel de procédure distante (RPC).

• Transact-SQL instruction EXECUTE.

Séquence d’échappement ODBC CALL

Si vous connaissez les informations de paramètre, appelez la méthode ICommandWithParameters ::SetParameterInfo pour décrire les paramètres au fournisseur. Sinon, lorsque la syntaxe ODBC CALL est utilisée pour appeler une procédure stockée, le fournisseur appelle une fonction d’assistance pour rechercher les informations de paramètre de procédure stockée.

Si vous n’êtes pas sûr des informations de paramètre (métadonnées de paramètre), la syntaxe ODBC CALL est recommandée.

La syntaxe générale pour appeler une procédure à l’aide de la séquence d’échappement ODBC CALL est la suivante :

{[ ?=]appelerprocedure_name[([paramètre][,[paramètre]]]... )]}

Par exemple:

{call SalesByCategory('Produce', '1995')}  

Séquence d’échappement RPC

La séquence d’échappement RPC est similaire à la syntaxe ODBC CALL d’appel d’une procédure stockée. Si vous appelez la procédure plusieurs fois, la séquence d’échappement RPC offre des performances optimales parmi les trois méthodes d’appel d’une procédure stockée.

Lorsque la séquence d’échappement RPC est utilisée pour exécuter une procédure stockée, le fournisseur n’appelle aucune fonction d’assistance pour déterminer les informations de paramètre (comme dans le cas de la syntaxe ODBC CALL). La syntaxe RPC est plus simple que la syntaxe ODBC CALL, de sorte que la commande est analysée plus rapidement, améliorant les performances. Dans ce cas, vous devez fournir les informations de paramètre en exécutant ICommandWithParameters ::SetParameterInfo.

La séquence d’échappement RPC nécessite que vous ayez une valeur de retour. Si la procédure stockée ne retourne pas de valeur, le serveur retourne un 0 par défaut. En outre, vous ne pouvez pas ouvrir un curseur SQL Server sur la procédure stockée. La procédure stockée est préparée implicitement et l’appel à ICommandPrepare ::P repare échoue. En raison de l’incapacité de préparer un appel RPC, vous ne pouvez pas interroger les métadonnées de colonne ; IColumnsInfo ::GetColumnInfo et IColumnsRowset ::GetColumnsRowset retournent DB_E_NOTPREPARED.

Si vous connaissez toutes les métadonnées de paramètre, la séquence d’échappement RPC est la méthode recommandée pour exécuter des procédures stockées.

Voici un exemple de séquence d’échappement RPC pour appeler une procédure stockée :

{rpc SalesByCategory}  

Pour obtenir un exemple d’application qui illustre une séquence d’échappement RPC, consultez Exécuter une procédure stockée (à l’aide de la syntaxe RPC) et traiter les codes de retour et les paramètres de sortie (OLE DB).

instruction EXECUTE Transact-SQL

La séquence d’échappement ODBC CALL et la séquence d’échappement RPC sont les méthodes préférées pour appeler une procédure stockée plutôt que l’instruction EXECUTE . Le fournisseur OLE DB SQL Server Native Client utilise le mécanisme RPC de SQL Server pour optimiser le traitement des commandes. Ce protocole RPC augmente les performances en supprimant une bonne partie du traitement des paramètres et de l'analyse des instructions sur le serveur.

Voici un exemple de l’instruction Transact-SQL EXECUTE :

EXECUTE SalesByCategory 'Produce', '1995'  

Voir aussi

Procédures stockées