Appeler des fonctions et des procédures dans Oracle Database à l’aide du modèle de service WCF

Article
07/21/2023

L’adaptateur Microsoft BizTalk pour Oracle Database expose les procédures, les fonctions et les packages en tant qu’opérations. Dans le modèle de service WCF, ces opérations sont représentées en tant que méthodes sur un client WCF. Le modèle de service WCF et l’adaptateur Oracle Database :

Fonctions de support. La valeur RETURN de la fonction Oracle est exposée en tant que valeur de retour de la méthode cliente WCF. Les paramètres Oracle sont exposés en tant que paramètres (avec la direction appropriée définie ci-dessous) pour la méthode cliente WCF.
Procédures de support. Le premier paramètre OUT de la procédure Oracle est exposé en tant que valeur de retour de la méthode cliente WCF. Tous les autres paramètres Oracle sont exposés en tant que paramètres (avec la direction appropriée définie ci-dessous) pour la méthode cliente WCF.
Prise en charge des packages Oracle. Le nom de l’opération et l’espace de noms de ses types de paramètres sont qualifiés par le nom du package.
Prend en charge les fonctions et procédures surchargées.
Prise en charge des paramètres IN, OUT et IN OUT pour les types de données Oracle de base pour les procédures et les fonctions. Les paramètres OUT sont exposés en tant que paramètres out sur la méthode cliente WCF et les paramètres IN OUT sont exposés en tant que paramètres ref .
Prise en charge des paramètres IN, OUT et IN OUT REF CURSOR pour les procédures et les fonctions, ainsi que les valeurs de fonction RETURN. Pour plus d’informations, consultez Exécution d’opérations à l’aide de CURSEURS REF dans Oracle Database à l’aide du modèle de service WCF.
Prise en charge des paramètres de type IN, OUT et IN OUT RECORD pour les procédures et les fonctions, ainsi que les valeurs de fonction RETURN. Pour plus d’informations, consultez Exécution d’opérations à l’aide de types RECORD dans Oracle Database à l’aide du modèle de service WCF.

À propos des exemples utilisés dans cette rubrique

Les exemples de cette rubrique utilisent la procédure surchargée /SCOTT/Package/ACCOUNT_PKG/GET_ACCOUNT. Cette procédure lit un enregistrement de la table SCOTT/ACCOUNT en fonction d’un ID de compte ou d’un nom de compte. Un script pour générer cette procédure et cette table est fourni avec les exemples sdk. Pour plus d’informations sur les exemples de KIT de développement logiciel (SDK), consultez Exemples dans le Kit de développement logiciel (SDK).

Classe de client WCF

Le tableau suivant indique le nom du client WCF et la méthode générée pour les procédures, fonctions et packages exposés par l’adaptateur Oracle Database. À moins qu’une fonction ou une procédure ne soit surchargée, un seul client WCF est utilisé pour appeler toutes les fonctions d’un schéma, toutes les procédures d’un schéma ou toutes les fonctions et procédures d’un package.

Artefact Oracle	Nom de l’opération du client WCF	Exemple
Procédure	[SCHEMA] ProcedureClient. [PROC_NAME]	SCOTTProcedureClient.MYPROC
Fonction	[SCHEMA] FunctionClient. [FUNC_NAME]	SCOTTProcedureClient.MYFUNC
Package (procédure ou fonction)	[SCHEMA] Package[PACKAGE_NAME]Client. [PROC_NAME ou FUNC_NAME]	SCOTTPackageMYPACKAGEClient.MYPROC

[SCHEMA] = Collection d’artefacts Oracle ; par exemple, SCOTT.

[PROC_NAME] = Nom d’une procédure Oracle ; par exemple, MYPROC.

[FUNC_NAME] = Nom d’une fonction Oracle ; par exemple, MYFUNC.

[PACKAGE_NAME] = Nom d’un package Oracle.

L’adaptateur Oracle Database représente les paramètres de type Oracle RECORD et les valeurs de retour, ainsi que les jeux de résultats retournés par les paramètres REF CURSOR en tant que types XML complexes qui contiennent les données de ligne (ou les champs) d’un enregistrement Oracle. Dans le modèle de service WCF, chacun de ces types XML est représenté sous la forme d’une classe .NET ; les propriétés de la classe représentent les champs du jeu de résultats de type RECORD ou REF CURSOR. Les types Oracle RECORD sont toujours représentés en tant que classes .NET fortement typées. Toutefois, un jeu de résultats REF CURSOR peut être représenté comme des enregistrements fortement typés ou faiblement typés selon que le CURSEUR REF lui-même est déclaré comme fortement typé ou faiblement typé. Les classes qui représentent des paramètres de type REF CURSOR ou RECORD (ou des valeurs de retour) sont générées dans un espace de noms unique basé sur la procédure, la fonction ou le package. Le tableau suivant présente ces espaces de noms.

Artefact Oracle	Espace de noms	Exemple
Procédure	[BASE_NS]. [SCHÉMA]. Procédure. [PROC_NAME]	microsoft.lobservices.oracledb._2007._03.SCOTT. Procedure.MYPROC
Fonction	[BASE_NS]. [SCHÉMA]. Fonction. [FUNC_NAME]	microsoft.lobservices.oracledb._2007._03.SCOTT. Function.MYFUNC
Package (Procédure)	[BASE_NS]. [SCHÉMA]. Paquet. [PACKAGE_NAME]. [PROC_NAME]	microsoft.lobservices.oracledb._2007._03.SCOTT. Package.MYPACKAGE.MYPROC
Package (Fonction)	[BASE_NS]. [SCHÉMA]. Paquet. [PACKAGE_NAME]. [FUNC_NAME]	microsoft.lobservices.oracledb._2007._03.SCOTT. Package.MYPACKAGE.MYFUNC
Jeu d’enregistrements générique (faiblement typé)	[BASE_NS]	microsoft.lobservices.oracledb._2007._03

[BASE_NS] = Espace de noms de l’adaptateur de base ; microsoft.lobservices.oracledb._2007._03.

[SCHEMA] = Collection d’artefacts Oracle ; par exemple, SCOTT.

[PROC_NAME] = Nom d’une procédure Oracle ; par exemple ; MYPROC.

[FUNC_NAME] = Nom d’une fonction Oracle ; par exemple MYFUNC.

[PACKAGE_NAME] = Nom d’un package Oracle.

Pour plus d’informations sur la façon dont ces espaces de noms sont utilisés pour les paramètres RECORD, consultez Exécution d’opérations à l’aide de types RECORD dans Oracle Database à l’aide du modèle de service WCF. Pour plus d’informations sur la façon dont ces espaces de noms sont utilisés pour les paramètres REF CURSOR, consultez Exécution d’opérations à l’aide de CURSEURS REF dans Oracle Database à l’aide du modèle de service WCF.

En général, les paramètres Oracle et les valeurs de retour sont mappés comme suit dans la méthode cliente WCF :

Les paramètres Oracle IN sont mappés aux paramètres .NET (entrée).
Les paramètres Oracle OUT sont mappés aux paramètres de sortie .NET.
Les paramètres Oracle IN OUT sont mappés aux paramètres ref .NET.
Les valeurs RETURN de la fonction sont mappées à la valeur de retour de la méthode.

Toutefois, deux exceptions importantes existent :
Les paramètres oracle IN OUT REF CURSOR sont divisés en une chaîne d’entrée et un jeu d’enregistrements de sortie (out). Cela est dû au fait que l’adaptateur Oracle Database représente les paramètres IN REF CUSROR en tant que chaînes et les paramètres OUT REF CURSOR en tant que types complexes (jeux d’enregistrements), ceux-ci ne peuvent pas être combinés en un seul paramètre.
Le premier paramètre OUT d’une procédure Oracle est mappé à la valeur de retour de la méthode cliente WCF. Il s’agit d’un comportement WCF standard.

L’exemple suivant montre une partie d’une procédure Oracle simple (chargée dans le schéma SCOTT) et la signature de la méthode cliente WCF générée pour l’appeler. La procédure Oracle a trois paramètres IN, trois paramètres IN OUT et trois paramètres OUT ; Toutefois, la méthode cliente WCF ne mappe pas de paramètre pour le premier paramètre OUT. Au lieu de cela, elle est mappée à la valeur de retour de la méthode.

CREATE or REPLACE PROCEDURE Sample_Procedure   
    (  
     INNUMBER      IN         NUMBER,  
     INVARCHAR     IN         VARCHAR2,  
     INDATE        IN         DATE,  
     INOUTNUMBER   IN OUT     NUMBER,  
     INOUTVARCHAR  IN OUT     VARCHAR,  
     INOUTDATE     IN OUT     DATE,  
     OUTNUMBER     OUT        NUMBER,  
     OUTVARCHAR    OUT        VARCHAR2,  
     OUTDATE       OUT        DATE  
    ) AS   
    BEGIN  
  
        ...  
  
    END;  
    /  
  
[System.Diagnostics.DebuggerStepThroughAttribute()]  
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]  
public partial class SCOTTProcedureClient : System.ServiceModel.ClientBase<SCOTTProcedure>, SCOTTProcedure {  
  
    public System.Nullable<decimal> SAMPLE_PROCEDURE  
       (  
        System.Nullable<decimal> INNUMBER,   
        string INVARCHAR,   
        System.Nullable\<System.DateTime\> INDATE,   
        ref System.Nullable<decimal> INOUTNUMBER,   
        ref string INOUTVARCHAR,   
        ref System.Nullable\<System.DateTime\> INOUTDATE,   
        out string OUTVARCHAR,   
        out System.Nullable\<System.DateTime\> OUTDATE  
        );  
}

Prise en charge des procédures, fonctions et packages surchargés

L’adaptateur Oracle Database prend en charge les procédures, fonctions et packages surchargés en ajoutant une chaîne unique à l’ID de nœud et à l’espace de noms qu’il expose pour chaque artefact surchargé. Cette chaîne est « overload1 » pour la première surcharge, « overload2 » pour la surcharge suivante, et ainsi de suite.

Dans le modèle de service WCF, chaque procédure ou fonction surchargée est représentée par un client WCF unique. Cela diffère du cas non surchargé dans lequel toutes les fonctions d’un SCHÉMA, toutes les procédures d’un SCHÉMA ou toutes les procédures et fonctions d’un PACKAGE sont appelées par le même client WCF. Le tableau suivant indique le nom et la méthode du client WCF générés pour les procédures, fonctions et packages surchargés.

Artefact Oracle	Nom du client WCF	Exemple
Package surchargé (procédure)	[SCHÉMA] Package[PACKAGE_NAME][PROC_NAME] ][OVERLOAD_ID]Client. [PROC_NAME]	SCOTTPackageMYPACKAGEMYPROCoverload1Client.MYPROC
Package surchargé (fonction)	[SCHÉMA] Package[PACKAGE_NAME][FUNC_NAME] ][OVERLOAD_ID]Client. [FUNC_NAME]	SCOTTPackageMYPACKAGEMYFUNCoverload1Client.MYFUNC

[SCHEMA] = Collection d’artefacts Oracle ; par exemple, SCOTT.

[PROC_NAME] = Nom d’une procédure Oracle ; par exemple ; MYPROC.

[FUNC_NAME] = Nom d’une fonction Oracle ; par exemple MYFUNC.

[PACKAGE_NAME] = Nom d’un package Oracle.

[OVERLOAD_ID] = chaîne unique qui identifie l’artefact surchargé ; « overload1 », « overload2 », et ainsi de suite.

Le tableau suivant montre l’espace de noms généré pour les procédures, fonctions et packages surchargés.

Artefact Oracle	Espace de noms	Exemple
Package (procédure)	[BASE_NS]. [SCHÉMA]. Paquet. [PACKAGE_NAME]. [PROC_NAME] [OVERLOAD_ID]	microsoft.lobservices.oracledb._2007._03.SCOTT. Package.MYPACKAGE.MYPROC.overload1
Package (Fonction)	[BASE_NS]. [SCHÉMA]. Paquet. [PACKAGE_NAME]. [FUNC_NAME]. [OVERLOAD_ID]	microsoft.lobservices.oracledb._2007._03.SCOTT. Package.MYPACKAGE.MYFUNC.overload1
Jeu d’enregistrements générique (faiblement typé)	[BASE_NS]	microsoft.lobservices.oracledb._2007._03

[BASE_NS] = Espace de noms de l’adaptateur de base ; microsoft.lobservices.oracledb._2007._03.

[SCHEMA] = Collection d’artefacts Oracle ; par exemple, SCOTT.

[PROC_NAME] = Nom d’une procédure Oracle ; par exemple ; MYPROC.

[FUNC_NAME] = Nom d’une fonction Oracle ; par exemple MYFUNC.

[PACKAGE_NAME] = Nom d’un package Oracle.

[OVERLOAD_ID] = chaîne unique qui identifie l’artefact surchargé ; « overload1 », « overload2 », et ainsi de suite. La valeur numérique dans la chaîne est l’ID de surcharge de l’artefact géré par la base de données Oracle.

L’exemple suivant montre les clients WCF et les signatures de méthode générées pour la procédure GET_ACCOUNT surchargée dans le package ACCOUNT_PKG. (Les déclarations Oracle sont incluses.) Cet exemple montre comment un client WCF unique est généré pour chaque surcharge et comment la méthode générée pour chaque client retourne un jeu d’enregistrements dans un espace de noms unique.

/* Procedure that takes account ID and returns record for existing account in the ACCOUNT table */  
PROCEDURE get_account(aid IN account.acctid%TYPE, acct OUT account%ROWTYPE) ;  
  
/* Procedure that takes account name and returns record for existing account in the ACCOUNT table */  
PROCEDURE get_account(aname IN account.name%TYPE, acct OUT account%ROWTYPE) ;  
  
[System.Diagnostics.DebuggerStepThroughAttribute()]  
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]  
public partial class SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload1Client : System.ServiceModel.ClientBase<SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload1>, SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload1 {  
  
    public microsoft.lobservices.oracledb._2007._03.SCOTT.Package.ACCOUNT_PKG.GET_ACCOUNT.overload1.ACCTRECORD GET_ACCOUNT(System.Nullable<decimal> AID);  
}  
  
[System.Diagnostics.DebuggerStepThroughAttribute()]  
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]  
public partial class SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload2Client : System.ServiceModel.ClientBase<SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload2>, SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload2 {  
  
    public microsoft.lobservices.oracledb._2007._03.SCOTT.Package.ACCOUNT_PKG.GET_ACCOUNT.overload2.ACCTRECORD GET_ACCOUNT(string ANAME);  
}

Appel de fonctions et procédures

Pour appeler une fonction ou une procédure à l’aide d’un client WCF, effectuez les étapes suivantes.

Générez une classe de client WCF pour la fonction, la procédure ou le package cible. Cette classe doit contenir des méthodes pour les opérations que vous allez appeler sur l’artefact cible.

Notes

Dans le plug-in Add Adapter Service Reference, les fonctions et procédures surchargées apparaissent dans la zone Catégories et opérations disponibles sous la forme [NAME].1, [NAME].2, [NAME].3, et ainsi de suite, où [NAME] est le nom de l’artefact surchargé et la valeur numérique est l’ID de surcharge de la base de données Oracle.
Créez une instance de la classe de client WCF et appelez ses méthodes pour appeler la fonction ou la procédure.

Pour plus d’informations sur la création d’une classe de client WCF et l’appel d’opérations sur l’adaptateur Oracle Database, consultez Vue d’ensemble du modèle de service WCF avec l’adaptateur de base de données Oracle.

L’adaptateur Oracle Database exécute chaque opération à l’intérieur d’une transaction sur la base de données Oracle.

Important

Les classes qui représentent les paramètres de type REF CURSOR et RECORD ou qui retournent des valeurs dans des fonctions ou des procédures (et des packages) sont déclarées dans un espace de noms unique pour chaque fonction ou procédure. Cela signifie, par exemple, qu’un type PACKAGE REF CURSOR utilisé comme valeur de retour dans deux fonctions différentes sera déclaré dans un espace de noms unique pour chaque méthode cliente WCF. Vous devez déclarer des variables distinctes pour contenir ces différentes valeurs de retour ou effectuer une conversion appropriée de la variable lorsque vous appelez l’une des méthodes clientes WCF.

L’exemple suivant illustre l’appel de la procédure /SCOTT/Package/ACCOUNT_PKG/GET_ACCOUNT surchargée pour obtenir les enregistrements de compte à partir de la table /SCOTT/ACCOUNT. Tout d’abord, un nouvel enregistrement est créé en appelant la procédure /SCOTT/Package/ACCOUNT_PKG/CREATE_ACCOUNT. Ensuite, le nouvel enregistrement est lu deux fois en appelant différentes surcharges de GET_ACCOUNT. Cet exemple utilise trois clients WCF, un pour la procédure CREATE_ACCOUNT et un pour les surcharges GET_ACCOUNT. Les alias sont utilisés pour faire la distinction entre les espaces de noms utilisés pour la valeur de retour de GET_ACCOUNT. Un exemple complet est disponible dans les exemples sdk. Pour plus d’informations sur les exemples de KIT de développement logiciel (SDK), consultez Exemples dans le KIT de développement logiciel (SDK).

using System;  
using System.Collections.Generic;  
using System.Text;  
  
// Add WCF, WCF Adapter LOB SDK, and Oracle Database adapter namepaces  
using System.ServiceModel;  
using Microsoft.ServiceModel.Channels;  
using Microsoft.Adapters.OracleDB;  
  
// Include this namespace for WCF Adapter LOB SDK and Oracle Database adapter exceptions  
using Microsoft.ServiceModel.Channels.Common;  
  
// Alias client namespaces to shorten declarations of "shared" types   
using CREATE_ACCOUNTns = microsoft.lobservices.oracledb._2007._03.SCOTT.Package.ACCOUNT_PKG.CREATE_ACCOUNT;  
using GET_ACCOUNT_BY_IDns = microsoft.lobservices.oracledb._2007._03.SCOTT.Package.ACCOUNT_PKG.GET_ACCOUNT.overload1;  
using GET_ACCOUNT_BY_NAMEns = microsoft.lobservices.oracledb._2007._03.SCOTT.Package.ACCOUNT_PKG.GET_ACCOUNT.overload2;  
  
// This sample demonstrates calling overloaded packaged procedures on Oracle  
// First a new account is created by calling CREATE_ACCOUNT which takes two record parameters  
// Then the information for the new account is returned by calling an overloaded procedure GET_ACCOUNT  
// The first overload returns the account information by account ID  
// The second overload returns the account information by account name  
// Notice that different clients (and namespaces) are created for overloaded procedures and functions  
namespace OracleOverloadsSM  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            decimal acctId;  
            string newAccountName = "Paula Bento";  
  
            Console.WriteLine("Creating clients");  
            // Create Client for CREATE_ACCOUNT Function  
            SCOTTPackageACCOUNT_PKGClient createAccountClient =   
                new SCOTTPackageACCOUNT_PKGClient("OracleDBBinding_SCOTT.Package.ACCOUNT_PKG");  
            // NOTE: user name and password are case-sensitive  
            createAccountClient.ClientCredentials.UserName.UserName = "SCOTT";  
            createAccountClient.ClientCredentials.UserName.Password = "TIGER";  
  
            // Create Client for GET_ACCOUNT Overload 1 -- takes ACCOUNT ID parameter  
            SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload1Client getAccountByIdClient =   
                new SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload1Client("OracleDBBinding_SCOTT.Package.ACCOUNT_PKG.GET_ACCOUNT.overload1");  
            // NOTE: user name and password are case-sensitive  
            getAccountByIdClient.ClientCredentials.UserName.UserName = "SCOTT";  
            getAccountByIdClient.ClientCredentials.UserName.Password = "TIGER";  
  
            // Create Client for GET_ACCOUNT Overload 2 -- takes ACCOUNT NAME parameter  
            // NOTE: this client can be created from configuration; detail provided here  
            // for demonstration  
            OracleDBBinding overload2Binding = new OracleDBBinding();  
            EndpointAddress overload2EndpointAddress = new EndpointAddress("oracleDB://ADAPTER");  
            SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload2Client getAccountByNameClient =   
                new SCOTTPackageACCOUNT_PKGGET_ACCOUNToverload2Client(overload2Binding, overload2EndpointAddress);  
            // NOTE: user name and password are case-sensitive  
            getAccountByNameClient.ClientCredentials.UserName.UserName = "SCOTT";  
            getAccountByNameClient.ClientCredentials.UserName.Password = "TIGER";  
  
            try  
            {  
                Console.WriteLine("Opening clients -- please wait");  
                // Open clients  
                createAccountClient.Open();  
                getAccountByIdClient.Open();  
                getAccountByNameClient.Open();  
  
                Console.WriteLine("Creating new account");  
                // Create an account record  
                // NOTE: ACCTRECORD is defined in all three namespaces so specify the definition  
                // that corresponds to the client.  
                CREATE_ACCOUNTns.ACCTRECORD acctRec = new CREATE_ACCOUNTns.ACCTRECORD();  
  
                // Set any value for ACCTID -- new account ID is returned by CREATE_ACCOUNT  
                acctRec.ACCTID = 0;  
                acctRec.NAME = newAccountName;  
                acctRec.BALANCE = 10537;  
  
                // Create address record  
                CREATE_ACCOUNTns.ACCOUNT_PKGADDRESS_REC_TYPERECORD addrRec = new CREATE_ACCOUNTns.ACCOUNT_PKGADDRESS_REC_TYPERECORD();  
                addrRec.STREET = "456 Valley Rd";  
                addrRec.CITY = "New York";  
                addrRec.STATE = "NY";  
  
                // Create account  
                acctId = (decimal)createAccountClient.CREATE_ACCOUNT(acctRec, addrRec);  
                Console.WriteLine("New Account Created: AccountId = {0}, Name = {1}, Balance = {2:C}",  
                   acctId, acctRec.NAME, acctRec.BALANCE);  
  
                /* Get new account by Id */  
                GET_ACCOUNT_BY_IDns.ACCTRECORD acctById = getAccountByIdClient.GET_ACCOUNT(acctId);  
                Console.WriteLine("Account Returned by Id: AccountId={0}, Name={1}, Balance={2:C}",  
                    acctById.ACCTID, acctById.NAME, acctById.BALANCE);  
  
                /* Get new account by Name */  
                GET_ACCOUNT_BY_NAMEns.ACCTRECORD acctByName = getAccountByNameClient.GET_ACCOUNT(newAccountName);  
                Console.WriteLine("Account Returned by Name: AccountId={0}, Name={1}, Balance={2:C}",  
                    acctByName.ACCTID, acctByName.NAME, acctByName.BALANCE);  
  
                Console.WriteLine("Hit <RETURN> to finish");  
                Console.ReadLine();  
            }  
            catch (TargetSystemException tex)  
            {  
                Console.WriteLine("Exception occurred on the Oracle Database");  
                Console.WriteLine(tex.InnerException.Message);  
            }  
            catch (ConnectionException cex)  
            {  
                Console.WriteLine("Exception occurred connecting to the Oracle Database");  
                Console.WriteLine(cex.InnerException.Message);  
            }  
            catch (Exception ex)  
            {  
                Console.WriteLine("Exception is: " + ex.Message);  
                if (ex.InnerException != null)  
                {  
                    Console.WriteLine("Inner Exception is: " + ex.InnerException.Message);  
                }  
                throw ex;  
            }  
            finally  
            {  
                // Close all the clients  
                createAccountClient.Close();  
                getAccountByIdClient.Close();  
                getAccountByNameClient.Close();  
            }  
  
        }  
    }  
}

Voir aussi

Développer des applications de base de données Oracle à l’aide du modèle de service WCF

Partager via

Appeler des fonctions et des procédures dans Oracle Database à l’aide du modèle de service WCF

À propos des exemples utilisés dans cette rubrique

Classe de client WCF

Prise en charge des procédures, fonctions et packages surchargés

Appel de fonctions et procédures

Voir aussi

Commentaires

Ressources supplémentaires