TDD pour les procédures Oracle stockées. Appeler les procédures stockées par Oracle SQL et exécuter Oracle Proceinte appel

Procédure stockée (procédure stockée) est un programme qui effectue certaines actions avec des informations dans la base de données et simultanément stockée dans la base de données elle-même. Dans Oracle, des procédures stockées peuvent être écrites dans les langues PL / SQL et Java.

Les procédures stockées peuvent saisir des paramètres et renvoyer les résultats. Contrairement aux déclencheurs, qui appartiennent à une table ou à une représentation spécifique, les procédures stockées appartiennent à la base de données dans son ensemble. Ils peuvent être appelés par n'importe quel processus utilisant une base de données, à condition que ce processus dispose de droits d'accès suffisants.

Les procédures stockées sont utilisées à plusieurs fins. Bien que les administrateurs de base de données utilisent-ils pour exécuter des tâches d'administration de routine, la zone principale de leur application est toutes les mêmes applications de base de données. Ces procédures peuvent être appelées à partir d'applications écrites dans des langues telles que Java, C #, C ++ ou VB.NET, ainsi que des scénarios Web écrits sur VBScript ou JavaScript. De plus, ces procédures peuvent être appelées en mode interactif à partir de la coque de commande SQL * Plus.

Les avantages suivants des procédures stockées peuvent être distingués:

Contrairement au code d'application, les procédures stockées ne sont jamais transmises aux ordinateurs clients. Il est toujours dans la base de données et les SGBD sont effectués sur l'ordinateur où se trouve le serveur de base de données. Ainsi, ils sont plus sûrs que le code d'application distribué et, en outre, réduire le trafic réseau. Les procédures stockées deviennent progressivement la mise en œuvre préférée de la logique d'application sur Internet et des intranets d'entreprise. Un autre avantage des procédures stockées est que les opérateurs SQL peuvent être optimisés par le compilateur DBMS.

Un exemple de procédure stockée

Supposons, pour notre exemple, il est nécessaire d'ajouter des informations sur les nouveaux clients à la base de données et de ce que les artistes sont intéressés. En particulier, vous devez enregistrer le nom et le numéro de téléphone du client, ainsi que de le lier avec tous les artistes de la nationalité sélectionnée.

Le listage 4.6 montre la procédure stockée qui effectue cette tâche. Une procédure appelée client_insert reçoit quatre paramètres: newname (nouveau nom du client), Newareacode (code de région), NewPhone (téléphone) et artiste (nationalité de l'artiste). Le mot clé IN indique que tous ces paramètres sont entrés. Les paramètres de sortie (que cette procédure ne possèdent pas) sont désignés par le mot-clé ou les paramètres qui jouent le rôle et la saisie et le week-end, en combinant dehors. Il convient de noter que seul le type de données est spécifié pour le paramètre et la longueur n'est pas spécifiée. Oracle déterminera la longueur du contexte.

Inscription 4.6.

Créer ou remplacer la procédure client_insert (
nEWNAME EN CHAR, NEWREACECODE EN CHAR, NEWPHONE EN CHART,
artistationnalité en caractère.
Comme
rowCount Entier (2);
Curseur Artistcursor est sélectionné Artistidid de l'artiste
Où la nationalité \u003d artisanalité;
Commencer.
Sélectionnez Count (*) dans RowCount du client
Où nom \u003d newname et AreaCode \u003d Newareacode et Phonenumber \u003d Newphone;
Si RowCount\u003e 0 alors commence
Dbms_output.put_line ("Il y a un client dans dB! Compte est" I I RowCount); Revenir;
Finir; FIN SI;
Insérer dans le client.
(Clientld, nom, code de section, phonenumber)
Valeurs (putad.nextval, newname, Newareacode, NewPhone);
Pour l'artiste en boucle d'artiste
Insérer dans Customer_Artist_int (CompteLLD, Artistid)
Valeurs (CUSID.Currval, artiste.Artist ID); Boucle de fin;
Dbms_output.put_line ("Client est ajouté!");
Finir;
/

La section déclarations variables suit le mot-clé. L'instruction SELECT définit la variable de curseur (variable de curseur) nommé artistecursor. Ce curseur met en évidence la table d'artiste pour gérer la rangée de tous les artistes d'une nationalité donnée.

Dans la première partie de la procédure, il est coché s'il existe des informations sur ce client dans la base de données. Dans ce cas, aucune action n'est prise et l'utilisateur à l'aide du package Oracle DBMS_Output est affiché. Il convient de noter que la syntaxe suivante est utilisée pour afficher la chaîne et la valeur de la variable:

Dbms_output.put_line ("<строка>"JE.<переменная>);

L'utilisateur recevra ce message uniquement si la procédure est appelée à partir de SQL * Plus. En cas d'appel de la procédure d'une manière différente, par exemple, à l'aide d'un navigateur via Internet, l'utilisateur ne verra pas ce message. Pour informer l'utilisateur de l'erreur, le développeur doit utiliser le paramètre de sortie ou générer une exception.

De plus, ces messages sont visibles, la commande doit être exécutée.

Set ServerOutput sur;

Si vous ne voyez pas de messages avec vos procédures lorsque vous travaillez dans SQL * Plus, vous n'avez pas rempli cet opérateur.

La partie restante de la procédure dans la liste 4.6 insère les données sur le nouveau client, puis traverse tous les artistes de la nationalité sélectionnée. Faites attention à l'utilisation d'un design spécial PL / SQL pour artiste dans l'artiste de l'artiste. Cette conception effectue plusieurs tâches. Tout d'abord, il ouvre le curseur et lit la première chaîne. Il traite ensuite séquentiellement toutes les lignes sous le curseur et lorsque le traitement est terminé, l'opérateur suivant contrôle après. Notez également que l'appel à la colonne Artistid de la ligne de courant se produit à l'aide de la syntaxe artistique.Artistid, où artiste est le nom du cycle Variable V et non le curseur.

Une fois la procédure écrite, elle doit être compilée et enregistrée dans la base de données. Si le texte de la procédure est enregistré dans le fichier, la procédure sera compilée et enregistrée dans la base de données automatiquement après avoir entré la commande.

start_file_processories

Si vous avez entré quelque chose de mal, vous pouvez avoir des erreurs de compilation. Malheureusement, SQL * Plus ne vous montrera pas automatiquement ces erreurs, mais émettra un message "AVERTISSEMENT: procédure créée avec des erreurs de compilation" (AVERTISSEMENT: Les erreurs sont détectées lors de la compilation de la procédure). Pour voir les erreurs, entrez la commande:

Montrer des erreurs;

S'il n'y avait pas d'erreurs de syntaxe, vous recevrez le message "Procédure créée" (procédure créée). Vous pouvez maintenant appeler cette procédure à l'aide de la commande Execute ou Exec:

EXEC Customer_Insert ("Banc Michael", "203", "555-2014", "US");

Si des erreurs se produisent au stade d'exécution de la procédure, les numéros de lignes du rapport d'erreur ne correspond pas aux numéros de ligne que vous pouvez voir dans votre éditeur de texte.

Dans l'un de nos projets récents, nous avons rencontré un grave problème. La demande Web que nous avons développée aurait dû utiliser la base de données interne de l'organisation financière. Pour des raisons de sécurité, l'accès était très limité: toute modification nécessaire pour être effectuée à l'aide de procédures stockées et que la lecture des données est uniquement à l'aide de représentations. Ainsi, l'application aurait dû être effectuée par des manipulations de données complexes, sans aucune idée de leur structure. Le principal harnais pour nous était que notre application est tombée en dépendance à des procédures importantes et complexes, pour lesquelles des tests automatisés n'existaient pas.

Google Un peu, nous avons constaté que les outils Oracle SQL Developer ont une fonctionnalité pour créer des tests automatisés. Nous avons immédiatement commencé à étudier. Et bien que les tests de la procédure la plus difficile devaient être créés après sa rédaction, cette boîte à outils nous a toujours aidés à éliminer plusieurs erreurs et a également facilité de manière significative le processus d'élargissement des fonctionnalités et de refactorisation. Ci-dessous, je citerai un exemple d'utilisation de TDD pour créer des procédures stockées, ainsi que des expériences de partage de travail avec des outils.

Exemple d'utilisation

Supposons que le client ait une application existante qui permet à ses clients d'envoyer des SMS. Une autre équipe développe une nouvelle application qui devrait fonctionner parallèlement à l'existant. Il serait donc bon d'avoir un lieu commun pour la logique des entreprises.

Structure de données

L'application utilise la structure de données suivante:

Créer des clients de table (numéro d'identification généré par défaut comme identité non , Nom Nvarchar2 (255) Not Null, Balance Number (*, 2) Par défaut 0 Not Null, IS_ACTIVE Numéro (1) Par défaut 0 Not NULL, IS_PREPAY Number (1) 0 pas null); Créer une table Message_Queue (numéro d'identification généré par défaut comme identité Non NULL, ID_CLIENT Numéro Numéro NULL, SENDER VARCHAR2 (20), VARCHAR (20), MESSAGE NVARCHAR2 (255) Non NULL, SEULEMENT_ON TIMESTAMP avec le fuseau horaire Current_Timestamp, Send_on Timeestamp avec Fuseau horaire NULL, SENT_ON TIMESTAMP avec le fuseau horaire NULL); Créer des transactions de tableau (numéro d'identification généré par défaut comme identité non , ID_CLIENT Numéro NON NULL, NUMÉRO DE VALEUR (*, 2) Non NULL, TRANSACTION_TEME TIMESTAMP avec le fuseau horaire Current_Timestamp);

Pour une brièveté, des définitions des clés primaires et externes sont omises.

Régler l'environnement

Test de l'unité dans SQL Developer utilise une base de données pour stocker des tests, leurs réglages, leurs bibliothèques et leurs résultats d'exécution. À cette fin, il est fortement recommandé de créer un utilisateur pour tester, puis de créer dans sa base de données de référentiel. Ce processus est décrit plus en détail dans la documentation sur les tests unitaires.

Terminologie des tests Oracle

La terminologie de test selon laquelle Oracle utilise est quelque peu différente du terme Xunit généralement accepté:

Surprendre

Travailler avec l'application, nous avons constaté que cela ne fonctionne pas toujours comme prévu:

Parfois, tous les éléments de menu des tests de l'unité ont été déconnectés. Dans de tels cas, vous devez cliquer sur l'élément de menu. Afficher → Test de l'unité
Tous les tests à l'intérieur du script utilisent un ensemble général de configuration et de réinitialisation contextuelle, qui est assez logique. Mais en raison du fait qu'ils sont édités dans l'onglet Test, le sentiment est créé qu'ils peuvent être personnalisés pour chaque test séparément.

Développement utilisant des tests

Avant de pouvoir commencer, vous devez créer une procédure vide, sinon il est impossible de créer un test. Et bien que la liste des arguments puissent être laissée en blanc, il n'y a pas besoin de cela.

Initialement, nous pouvons supposer que pour envoyer un message, nous aurons besoin d'un identifiant client, de l'expéditeur, du destinataire, ainsi que du corps du message lui-même. De plus, nous devons signaler le résultat d'exécution, disons, via le paramètre de sortie. En utilisant la boîte de dialogue Création de la procédure, vous pouvez obtenir une définition assez appropriée:

Créer ou remplacer la procédure Queue_Mesessage (V_ID_CLIENT IN NUMÉRO, V_SENDER IN VARCHAR2, V_RECIPIPIENT EN VARCHAR2, V_MESSAGE dans NVARCHAR2, V_IS_SUREUTED Numéro de sortie) Comme commence Null; Mettre fin à la queue_message;

Dans le cas d'Oracle, il est logique de définir le préfixe pour les variables dont le nom peut coïncider avec le nom du champ, car en cas d'ambiguïté, le célèbre SGBD résoudra le différend en faveur du champ. Et pour éviter les troubles, il est plus facile de donner au préfixe à toutes les variables sans exception.

Noter
Si les paramètres de procédure ont changé, chaque script de test doit être mis à jour manuellement en cliquant sur l'élément de menu contextuel. Synchroniser le test ...

Premier scénario

Pour simplifier notre exemple, supposez que le coût d'un message est de 0,03 d'argent. Et, assez curieusement, pour décrire le script convient parfaitement à Gherkin:

DANAR: Client post-payé actif Lorsque: il envoie un message: un résultat positif est renvoyé et le coût du message est fixé dans le journal des transactions, de plus, le message est ajouté à la file d'attente.

Le moyen le plus rapide de créer un test - cliquez sur le bouton droit de la souris sur la procédure dans l'arborescence de l'objet, puis sélectionnez l'élément de menu. Créer un test de l'unité .... Dans la fenêtre qui apparaît, vous pouvez appuyer immédiatement sur le bouton. TERMINER.. Scénario Queue_Message. avec le seul test doit apparaître dans le panneau Test de l'unité.

Cadre de contexte

Premièrement, nous devrons remplir la base de données avec des données sans réserve. Pour nous, le plus pratique était l'utilisation du mode PL / SQL pour configurer et réinitialiser le contexte. Cependant, toutes les options sont faciles à utiliser à nouveau à l'aide de la publication à la bibliothèque. Pour copier une étape existante de la bibliothèque, il suffit de le sélectionner dans la liste déroulante, puis sur le bouton Copie. Et si vous avez besoin de l'utiliser inchangé, mais au lieu d'un bouton Copie Il est nécessaire d'appuyer sur Chekbox S'abonner..

Mise en garde!
L'idée d'utiliser une base de données existante pour les tests peut sembler attrayante. Il semblerait que vous auriez enregistré les données dans le réglage et restauré lorsque le contexte est réinitialisé ... Cependant, il convient de garder à l'esprit que s'il y a eu une erreur inattendue dans le test des tests à n'importe quel stade, la La base de données sera sous la forme dans laquelle il se trouvait pendant l'erreur et la réinitialisation du contexte ne sera pas effectuée. Par conséquent, il est préférable d'utiliser une base de données pure, qui n'est pas effrayante et facile à ré-recréer en cas de flux ou de données.

En supposant que nous travaillions avec une base de données vide, pour la teinture de contexte, nous n'avons besoin que d'une seule entrée d'insertion du client post-payé. Il peut être enregistré immédiatement dans la bibliothèque, appelant Client après paiement.

Réinitialiser le contexte

Pour pouvoir réexécuter des tests, vous devez nettoyer les données ajoutées. Une chose, dans notre cas, vous pouvez simplement effacer toutes les tables affectées par les tests. Cette étape doit également être enregistrée dans la bibliothèque pour une utilisation ultérieure.

Appel

Directement, le test est déterminé en définissant les paramètres de la procédure stockée. Voici les valeurs des paramètres de sortie pour la vérification. Les paramètres de sortie de numérisation peuvent être déconnectés à l'aide de la case à cocher Résultat du test. Il fait référence aux paramètres spécifiés à la fois dans la table et de manière dynamique.

Mise en garde!
Il peut sembler de préciser les paramètres de la table très pratique, mais il est nécessaire de garder à l'esprit que cette table n'est pas soumise à la copie. Ceci est particulièrement important pour les procédures avec un grand nombre d'arguments, car pour créer un autre test, ils doivent tous être mis à jour manuellement, en particulier lorsqu'un nouveau test diffère de la seule valeur actuelle. La requête de valeur dynamique, contrairement à la table, peut être enregistrée dans la bibliothèque, puis vous pouvez réutiliser ou copier.

Comme indiqué ci-dessus, la demande dynamique est plus pratique à utiliser. Il convient également de noter que le nom des paramètres de sortie de la requête doit être complété par le signe $ à la fin du titre:

Sélectionnez 1 comme v_id_client, "790522222222" comme v_ssender, "7916111111" comme v_recipient, "Walk Ida!" Comme v_message, 1 comme v_is_utilisé $ de Dual

Noter
Pour revenir du mode de requête dynamique à la table, vous devez préciser complètement la valeur de la demande dynamique.

Depuis que nous avons indiqué une vérification de paramètres de sortie, vous pouvez déjà exécuter le script et voir l'échec. Si tout est fait correctement, le système doit signaler une erreur. Toute autre défaillance à ce stade signifie un paramètre incorrect.

Le moyen le plus simple de calmer le test est l'inhibition de 1 dans le paramètre de sortie dans le corps de la procédure: Sélectionnez 1 dans IS_QUUEUTED de Dual;

Approbation

Le test est à nouveau vert, mais nous n'avons pas encore vérifié toutes les conditions nécessaires. Ils peuvent être vérifiés dans d'autres tests du même script. Avant de créer un nouveau test, il vaut la peine de renomiser le "résultat positif" existant à partir de la "mise en œuvre du test 1" par défaut, et l'ensemble du script est dans le "client actif post-paye envoie un message".

Important
Il est facile de supposer que chaque test est effectué à l'intérieur de la transaction. Cependant, il s'est avéré que ce n'est pas le cas. En cas d'erreur imprévue survient, la base de données peut être dans un état sous-sec. Les erreurs attendues ne concernent pas.

Notre vérification suivante sera placée dans un test séparé pour obtenir un retour de retour plus subtil, mais il est nécessaire de rappeler que chaque nouveau test passera du temps à la configuration et à la réinitialisation du contexte, et chaque échec de test est fourni avec un message clair sur sa raison. Nous divisons les vérifications sur différents tests dans ce scénario, puis combinez tous les chèques dans un test dans le scénario suivant.

Noter
SQL Developer ne vous permet pas d'afficher deux tests en même temps. Lors du passage à un autre test dans l'arborescence, le test actuel est remplacé par NEW dans le même panneau. De plus, il est impossible de diviser ce panneau pour deux zones défilées indépendamment. Cependant, il est très pratique d'ouvrir le code source de la procédure en parallèle à la fenêtre de test pour la transition rapide entre les deux panneaux.

Le test suivant doit vérifier que le message est placé dans la file d'attente. Étant donné que la configuration et la réinitialisation du contexte sont déjà spécifiées, nous devons utiliser une demande dynamique de la bibliothèque et demander une vérification de l'approbation. Après avoir copié la requête dynamique, il peut sembler de vérifier le paramètre de sortie déjà éprouvé à quoi que ce soit, et vous pouvez réinitialiser la chekbox Résultat du test. Cependant, si vous conduisez des tests dans un tel état, on verra que l'un des tests est ignoré. Pour moi personnellement, un test ignoré est un symbole de travail inachevé, de sorte que la case à cocher devra mettre en place.

Il existe plusieurs façons de vérifier les déclarations. Le premier point de la liste est une fonction booléenne. Lors de la création d'une fonction booléenne, le dialogue fournit un modèle assez approprié:

- Veuillez remplacer ce code par une expression boolean - comme ceci: - retourne faux; - ou bien un bloc de code qui retourne une valeur booléenne - semblable aux éléments suivants: Déclarez le numéro L_Count; Commencer à sélectionner le nombre (*) dans l_count de double; Si l_count.<> 0 puis retourne vrai; Sinon retourne faux; FIN SI; Finir;

Pour notre chèque, nous pouvons utiliser ce modèle en remplacement de Dual sur Message_Queue, puis appliquez les filtres nécessaires. La condition devra également changer avec l_count<> 0 sur l_count \u003d 1 pour une plus grande précision. Après cela, vous pouvez enregistrer en toute sécurité la fonction à la bibliothèque pour une utilisation ultérieure.

Noter
Toutes les entrées de la bibliothèque sont enregistrées en fonction de leur type. Cela signifie que si à l'avenir vous devrez utiliser, par exemple, une vérification de l'approbation, il sera nécessaire de rappeler non seulement son nom, mais également. Il peut très vite être très inconfortable, en particulier dans de grands projets.

Lorsque vous testez des tests, nous devons voir l'erreur. Il est très facile de le réparer:

Insérer dans Message_Queue (id_client, expéditeur, destinataire, message) Valeurs (v_id_client, v_ssender, v_recipient, v_message);

Maintenant, vous pouvez vous assurer que tous les tests réussissent.

Noter
Lorsque vous travaillez avec des tests, le référentiel est bloqué, donc à la fin du travail, il est nécessaire de fermer le développeur SQL ou de fermer le référentiel (République de désélection).

Et, enfin, vérifiez l'enregistrement de la transaction. Pour ce faire, choisissez le type de validation suivant - Comparez les résultats de la requête (comparer les résultats de la requête). Comme il résulte du nom, cela fonctionne très simplement: vous devez spécifier deux demandes dont les résultats coïncident. Comme il est impossible de connaître la date et l'heure exactes, vous pouvez être satisfait de toute valeur dans les 10 secondes:

- requête source Sélectionnez 1 comme ID_Client, 0.03 en tant que Sum_Value de la requête à double cible Sélectionnez ID_Client, Somme (valeur) des transactions où transaction_Time entre Current_Timestamp et (Current_Timetamp - 1/24/6) Groupe par ID_Client;

Après l'exécution des tests, nous voyons une erreur de validation vague. Une transaction récente: comparer les résultats de la requête Vérifier les différences trouvées. Où "une transaction récente" est le nom de notre dernier chèque dans la bibliothèque. Et bien que cette option soit déjà un outil précieux, ce serait merveilleux s'il pouvait montrer ce que les résultats diffèrent exactement.

Ajoutez la fonctionnalité souhaitée à notre procédure:

Insertion dans les transactions (id_client, valeur) valeurs (v_id_client, 0,03);

Débogage

Après la prochaine exécution des tests soudainement, il s'avère que l'erreur ne fait de rien. Vous avez probablement déjà remarqué l'erreur dans le code ci-dessus, mais dans des conditions réelles, il existe des situations beaucoup plus complexes. Depuis l'outil de différence sur les spectacles, vous devez découvrir la cause de la manuelle. Malheureusement, le développeur SQL fonctionnel de débogage est incapable d'aider. Cela signifie que nous devrons conduire un test sans effectuer une décharge. Pour ce faire, vous pouvez créer un autre scénario - Débogage. Ou plutôt deux: un - sans réinitialisation, mais avec la même demande dynamique que dans le test de non-travail - afin de comprendre ce que l'affaire est; Et le second - sans ajuster le contexte, mais avec une décharge - afin de supprimer le premier.

Après avoir démarré le premier scénario, vous pouvez voir le contenu de la table et vérifier auprès de la demande de vérification. Maintenant, il est clairement constaté que le problème était précisément dans la demande de vérification. Sans oublier de démarrer le deuxième script pour le nettoyage des données, corrigez les conditions de test et organisez une réutilisation. Maintenant tout va bien. Les scénarios de débogage peuvent être laissés pour l'avenir et le premier script complet peut être placé dans un nouvel ensemble de tests.

Deuxième scénario

Maintenant, lorsque nous avons un scénario d'un message de mandrin réussi, nous pouvons essayer le script d'expédition infructueuse. Par exemple, lorsque le client post-paiement est inactif:

DANAR: Client post-payé inactif Lorsque: il envoie un message, un résultat négatif est renvoyé et la transaction n'est pas corrigée et que la file d'attente du message reste inchangée.

Vous devez créer un nouveau script. Nous aurons également un peu pour corriger le contexte et la demande dynamique, mais il est déjà beaucoup plus facile que de créer de nouveau à partir de zéro.

Pour configurer le contexte, copiez la partie PL / SQL «Client après-paiement actif», dans laquelle nous remplaçons 1 à 0 et publier dans la bibliothèque intitulée «Client post-Pay inactif». Nous répétons la même chose pour une requête dynamique en appelant une nouvelle demande "message non délais". Pour réinitialiser le contexte, utilisez une étape existante.

Après la course, le test doit afficher une erreur. Il est très facile de le réparer. Nous remplaçons SELECT 1 dans v_is_utilisé de double sur Sélectionnez IS_Active In V_is_Quuquée des clients où id \u003d v_id_client - et tout fonctionne à nouveau.

Ensuite, vous devez vérifier que la transaction n'est pas enregistrée. Pour ce faire, nous utilisons le type de vérification suivant - comparer les tables (comparer les tables). Au début, cela peut sembler être comparé à quoi, cependant, dans le contexte, il est possible de copier le tableau existant en temporaire. Il est parfait pour nous - vous pouvez copier des transactions sur une table temporaire et après avoir appelé la procédure pour comparer les résultats. La principale chose n'est pas d'oublier cette table à supprimer lors de la réinitialisation du contexte. Il existe deux options - restaurer, puis supprimez et simplement supprimer. Puisque nous n'avons rien à restaurer - choisissez la deuxième option. Veuillez noter que comme dans le cas de la comparaison des demandes, la seule option de retour d'information est une coïncidence ou non.

Après avoir aimé une erreur après le test, vous pourriez penser sur la solution. Par exemple, vous pouvez envelopper des insertions d'insertion à l'aide de v_is_utilisé fraîchement mis à jour:

Si v_is_quueud \u003d 1 puis insérez dans les valeurs de transaction (ID_CLIENT, VALUE) (v_id_client, 0,03); FIN SI;

Terminez la procédure, exécutez des tests - tout fonctionne.

En conclusion, nous devons vérifier que la file d'attente des messages est restée inchangée. Et bien que les mains ont crié immédiatement, mettez immédiatement l'insertion du message à l'intérieur de l'état à côté de l'insertion de la transaction, elle favoriserait le trouble de la discipline. Par conséquent, créez d'abord un chèque supplémentaire pour cette approbation. Le type de vérification suivant est une demande qui ne renvoie pas les enregistrements (requête renvoyant aucune ligne de lignes). Puisque nous nettoyons entièrement toutes les données après chaque test, il suffira de spécifier la sélection * de Message_Queue comme une telle requête.

Test Run montre une erreur que nous nous échappons facilement en plaçant une insertion vers l'intérieur. Et cela met fin notre deuxième scénario.

conclusions

Le développeur SQL peut être utilisé pour développer des procédures stockées à l'aide de la méthode TDD. Malgré de nombreux inconvénients, ce paquet fournit une plate-forme de développement de procédures stockées, permettant aux développeurs de faciliter la facilité et de la confiance de modifier et d'élargir la fonctionnalité des procédures existantes.

Malheureusement, le référentiel de test ne peut être créé que dans Oracle DBMS. De plus, tente d'utiliser des DBM de type PostgreSQL tiers ou même MySQL en tant que base de données pour tester, se termine par l'effondrement du sous-système de test. Il a également découvert que l'utilisation d'un développeur SQL dans des systèmes d'intégration continue provoque de nombreux problèmes, mais c'est déjà une histoire séparée.

et EXEC SP () et Call SP () peuvent être utilisés dans SQL * Plus pour exécuter SP. Au fait, vous pouvez également utiliser Begwe Sp (); Finir;

mais il y a des différences.

L'appel est Oracle SQL et devrait fonctionner partout. Les autres clients de la base de données pouvant communiquer avec Oracle peuvent prendre en charge ou gérer SQL * Plus EXEC. Beaucoup (par exemple, Développeur ORACLE SQL, SQLWORKBEND / J), mais certains ne sont pas (LIBIBASE).

types de données des paramètres transmis L'appel L'opérateur doit être des types de données SQL. Ils ne peuvent être que des types de données de PL / SQL, tels que Boolean.

Exec peut être utilisé pour exécuter non seulement SP, mais également un opérateur arbitraire.

si SP n'a pas de paramètres, vous pouvez utiliser Exec SP; Syntaxe, mais l'appel nécessite des crochets vides: appelez SP ();

Si vous appelez le processus, qui renvoie SYS_Refcursor à l'aide du crapaud, il existe une différence entre Call and Exec.

créer une procédure FOO (I en nombre, O OUT SYS_REFCUURSOR) Comment commencer à ouvrir pour sélectionner I de Dual; finir;

eXEC FOO (1 ,: R); - Affiche 1 chaîne

appeler foo (1,: r); - Affiche 0 lignes

Remarque: lorsque vous préfixez un paramètre avec un côlon, le crapaud vous offrira un type (dans ce cas le curseur).

Exécuter prend une chaîne en tant que paramètre qui vous permet de "exécuter" SQL dynamique. Principalement dites ... avec cette ligne d'entrée, exécutez le moteur SQL sur le contenu.

l'appel transmet le contrôle de la procédure ou du module stocké.

Comme vous pouvez le constater, ils sont conceptuellement différents. Cependant, si vous effectuez simplement la procédure, dans la pratique, pour ce mode de réalisation, ils sont les mêmes.

Je crois que pour un code clair, si vous n'avez pas besoin d'exécuter, vous devez utiliser un appel.

P. 19-1.

Chapitre 19.

Écrire des modules logiciels

Ce chapitre explique la création de sous-routines avec le nom d'utilisateur (procédures et fonctions PL / SQL), que vous pouvez ensuite appeler des déclencheurs et d'autres sous-programmes avec le nom d'utilisateur dans les modules des formulaires, des menus et des bibliothèques. Il comprend les sujets suivants:

À propos des sous-routines pour le nom d'utilisateur19 - 2

Création d'un sous-programme avec le nom de l'utilisateur19 - 3

Appelez les sous-routines pour le nom d'utilisateur19 - 7

Définition des paramètres19 - 8

PLAYAGES PL / SQL19 - 10

P. 19-2.

À propos des sous-routines pour le nom d'utilisateur

Subiltine avec nom d'utilisateur - Ceci est une fonction ou une procédure PL / SQL avec le nom que vous écrivez sur le formulaire de module, les menus ou la bibliothèque. Bien que la voie principale d'ajouter le contrôle logiciel sur les applications Oracle Forms sont des déclencheurs, les sous-programmes avec le nom d'utilisateur complètent les déclencheurs, ce qui vous permet de réutiliser le programme sans l'inversion à la réintroduire dans plusieurs déclencheurs.

Contrairement aux déclencheurs, qui sont exécutés en réponse aux événements du programme d'événements, les sous-programmes avec le nom d'utilisateur doivent être appelés explicitement dans votre programme de candidature. Le sous-programme avec le nom de l'utilisateur que vous définissez dans le formulaire de module peut être appelé à partir de tout déclencheur de ce module.

En tant que sous-programmes intégrées, enregistrez vos efforts pour écrire des programmes pour des fonctions générales, tels que la navigation et l'interaction avec la base de données, et les sous-programmes avec le nom d'utilisateur vous fournissent une méthode de réutilisation spécifique au programme que vous avez vous-même écrit.

Si vous constatez que vous écrivez les mêmes lignes du programme dans plusieurs commandes de déclenchement ou d'élément de menu, vous devrez plutôt réfléchir à la rédaction d'un sous-programme avec le nom d'utilisateur.

Dans la plupart des programmes d'applications, les opérateurs peuvent effectuer les mêmes opérations de plus d'une manière et de plus d'une fenêtre ou d'un menu. Par exemple, le programme d'application de saisie d'applications peut permettre à l'opérateur de calculer le résultat par ordre en appuyant sur la touche, cliquez sur le bouton ou sélectionnez dans le menu Menu. Sans sous-programme avec le nom de l'utilisateur, vous devez écrire la même formule de calcul dans la gâchette de clé, le déclencheur de la touche de roue et la commande d'élément de menu.

Il est préférable d'écrire la formule de calcul une fois dans le sous-programme avec le nom d'utilisateur. Vous pouvez donner à ce sous-programme un nom significatif, disons, calculez_totals.puis appelez-le par nom de tout élément de déclenchement ou de menu dans lequel cette formule est requise.

Comme les sous-routines intégrées, les sous-programmes avec le nom d'utilisateur peuvent prendre des paramètres. Lorsque vous déclave les paramètres du sous-programme, vous spécifiez leur type de données, leur mode et leurs valeurs par défaut, le cas échéant. En utilisant les paramètres pour transmettre des valeurs valides, vous pouvez créer plus de sous-programmes généraux à l'aide des valeurs que vous donnez programmable pendant l'exécution.

P. 19-3.

Créer des sous-routines pour le nom d'utilisateur

Les sous-programmes avec le nom d'utilisateur sont nommés d'objets que vous définissez dans des modules de formulaire, menus ou bibliothèque.

Pour créer un sous-programme avec un nom d'utilisateur:

Pendant le navigateur, sélectionnez le nœud Unités de programme souhaité, puis sélectionnez Navigator-\u003e Créer.

La boîte de dialogue Nouvelle unité de programme apparaît.

Des informations sur les commandes de l'éditeur PL / SQL sont disponibles au chapitre 2 "Utilisation des outils de conception".

Pour créer, spécifiez le nom du module logiciel de nom, puis définissez son type (procédure, fonction, spécification de package ou corps de package).

Composez et compilez la procédure que vous définissez ou fonctionne.

Composez la définition complète de la procédure ou de la fonction à l'aide de la structure standard et de la syntaxe PL / SQL. Pour plus d'informations, voir les sections "Procédure" et "Syntaxe de fonction" plus tard dans ce chapitre.

Pour compiler un module logiciel, sélectionnez Compiler.

Noter: Oracle Forms appliquera automatiquement vos modifications lorsque vous fermez l'éditeur, même si vous avez compilé le module de programme infructueux.

Oracle Forms affiche le nom de chaque module de programme avec Annotation indiquant son type (procédure corporelle, spécification de package, etc.). Par exemple, le corps de la procédure sera annoté comme suit:

calculez_totals (corps de procédure)

Et la spécification de paquet ressemblera à ceci:

Manutes d'erreur (spécification de package)

P. 19-4

Procédures de syntaxe

spécification Les procédures commencent par le mot-clé de la pranation et se termine par le nom de la procédure ou la liste des paramètres formels. Corps Les procédures commencent par un mot clé et se termine par un mot clé fin avec un nom ultérieur optionnel de cette procédure.

Syntaxe:

PROCEDURE PROCÉDURE_NAME est.

Commencer.

déclarations

Finir;

où:

nom de procédure.	Procédure unique définie par l'utilisateur. Ce nom doit être conforme aux conditions de dénomination Oracle. Des informations supplémentaires peuvent être trouvées dans Manuel de référence de la langue SQL.
liste d'arguments	où:
var_Name.
mode.	Ceci (!! Sous !! dans \| out \| sortir).
taper
valeur	Expression pl / sql.
local_variable_declaration
déclarations
exception_handler	Parler à .

P. 19-5

Caractéristiques de la syntaxe

Chaque fonction doit exécuter l'instruction de retour. La déclaration de retour définit la valeur de retour de la fonction et renvoie immédiatement le contrôle de la gâchette, le sous-programme avec le nom d'utilisateur ou la commande d'élément de menu, à partir de laquelle la fonction a été appelée.

Syntaxe:

Fonction Function_Name est.

Commencer.

déclarations

Retour (Rezult);

Finir;

où:

function_Name.	Nom d'utilisateur unique fonctionnalité définie. Ce nom doit être conforme aux conditions de dénomination Oracle.
liste d'arguments	Ceci ((Var_NameType [: \u003d valeur]) [, ...]) où:
var_Name.	Le nom unique de la variable locale.
mode.	Ceci est (in \| sortir)).
taper	Il )(,...)]
déclarations	Déclarations exécutables pl / sql.
exception_handler	Parler à Guide de l'utilisateur PL / SQL et référence.
rÉSULTAT	Expression dénotant la valeur de la fonction. La valeur d'expression doit être compatible avec le type spécifié dans la spécification de fonction.

P. 19-6

Exemple de procédure:

La procédure suivante traite la commande en réduisant le résidu pour un produit particulier. Pour appeler cette procédure, vous transmettez l'identifiant du produit, le nombre d'unités commandées et un entrepôt qui devraient remplir cette commande:

PROCÉDURE DO_ORED (Unités_ordorked en nombre,

prod_id en nombre,

l'entrepôt en nombre) est

unités_in_stocknumber;

Commencer.

Sélectionnez Montant_in_stock dans Unités_in_stock à partir de l'inventaire

Où produit_id \u003d prod_id

Et warehouse_id \u003d entrepôt;

Si unités_in_stock\u003e \u003d unités_in_stock - unités_ordordies alors

Mettre à jour l'inventaire.

Définir montant_in_stock \u003d unités_in_stock - Unités_Ortones

Où produit_id \u003d prod_id;

AUTRE.

Message ('' réserve ne suffit pas ')

Élever forme_trigger_failure;

FIN SI;

Finir;

Vous pouvez utiliser cette procédure dans la gâchette comme suit:

do_order (: order.units, commander.prod_id ,: warehouse.id);

Dans cet exemple, la valeur de trois paramètres formels est la valeur actuelle des éléments sous la forme spécifiée par la syntaxe standard de la variable connectée:

: block_name.Item_name.

Exemple de fonction:

La fonction suivante renvoie la quantité de produits dans la réserve sur un entrepôt spécifique. Appeler une fonction, vous transmettez l'identificateur de produit et un entrepôt Identification:

Fonction get_inventory (numéro de produit, numéro d'entrepôt)

Le numéro de retour est.

nombre de montant;

Commencer.

Sélectionnez Montant_n_stock en montant de l'inventaire

Où produit_id \u003d produit et warehouse_id \u003d entrepôt;

Montant de retour;

Exception

Quand d'autres alors.

Message («Nom du produit ou identifiant de l'entrepôt»);

Retour (-1);

Finir;

P. 19-7

Vous pouvez utiliser cette fonctionnalité dans la gâchette comme suit:

Déclarer.

invnumber;

montant_requikedNumber: \u003d: ordre_block.order_item;

Commencer.

inv: \u003d get_inventory (: produit_id ,: warehouse.id);

Si inv.< 0 THEN

Voici le traitement des erreurs

Sinon si INV\u003e \u003d montant_requiked alors

Voici l'ordre de commande

FIN SI;

Finir;

Appelez les sous-sources pour le nom d'utilisateur

Les procédures d'appel et les fonctions avec le nom de l'utilisateur sont similaires à l'appel dans les procédures et fonctions intégrées; Vous pouvez utiliser des paquets nominaux et de position pour transmettre des paramètres. Dans les sous-programmes avec le nom d'utilisateur, vous pouvez accéder aux objets de formulaire exactement comme vous le faites avec la liste des paramètres dans les sous-routines intégrées.

Lorsque vous générez un module du formulaire ou du menu pour créer un fichier exécutable, les formulaires Oracle doivent pouvoir trouver n'importe quel sous-programme causé par ce module. Ce que ce sous-programme peut être causé, indique le module dans lequel il est défini.

Développer un programme d'application contenant plus d'un module, examiner les règles suivantes de la portée:

· le sous-programme avec le nom de l'utilisateur défini dans le module du formulaire peut être appelé uniquement à partir de déclencheurs et d'autres sous-programmes avec le nom d'utilisateur dans le même module.

· le sous-programme avec le nom de l'utilisateur défini dans le module de menu ne peut être appelé que sur les commandes de menu et les programmes de démarrage dans le même module.

· le sous-programme avec le nom de l'utilisateur défini dans le module de bibliothèque peut être appelé à partir de toutes les commandes de déclenchement ou d'élément de menu, à condition que cette bibliothèque soit connectée au module du formulaire ou du menu.

P. 19-8

Vous ne pouvez pas créer une bibliothèque de publications avec un nom d'utilisateur en écrivant des procédures et des fonctions directement dans un module de bibliothèque ou en copie dans la bibliothèque des sous-programmes à partir d'autres modules. Pour plus d'informations sur la bibliothèque, voir le chapitre 20 "Travailler avec des bibliothèques".

Définition des paramètres

L'utilisation de paramètres est facultative. Les sous-programmes qui ne reçoivent pas de paramètres ne sont pas écrits sans crochets. Si vous déclarez le paramètre, vous devez spécifier le type de données et le mode dans la liste des paramètres.

Types de paramètres de données Les paramètres peuvent être déclarés comme varchar2, date, nombre ou types booléens, ou tout type d'objets Oracle Forms. En créant une fonction ou une procédure, entrez le type de données après chaque nom de paramètre formel:

PROCÉDURE DISPLAY_OVERDUE_SPLATIONS (NUMÉRO DEPT_ID);

Fonction Credit_OK (client Varchar2) retour booléen;

Modes de paramètres Le mode paramètre peut être (par défaut), out ou sortir. Le paramètre en transmet la valeur du sous-programme. Le sous-programme peut lire la valeur du paramètre en paramètre, mais ne peut pas enregistrer sa valeur. Le paramètre réel peut être une variable ou une expression constante, littérale, initialisée.

Le paramètre Out renvoie une valeur du sous-programme. Le paramètre de sortie réel peut être une variable locale (non connectée) et le sous-programme doit affecter la valeur à cette variable. Si cela ne se produit pas, l'exception prédéfinie PL / SQL No_Data_Found sera causée.

Le paramètre in Out transmet la valeur du sous-programme et renvoie la valeur du sous-programme. Le paramètre réel dans Out peut être une variable locale ou une variable connectée. Le sous-programme peut enregistrer la valeur du paramètre Out Out, mais pas nécessairement.

Les fonctions et les procédures peuvent prendre et sortir des paramètres. La procédure renvoyant la valeur via le paramètre OUT ou OUT fonctionne de la même manière que la fonction et peut être utilisée pour tous les cas pour lesquels des fonctions sont généralement utilisées.

Si vous spécifiez la procédure ou la spécification de fonction, n'observez pas le mode de paramètre formel explicitement, ce paramètre est déclaré comme paramètre dans. Ainsi, les spécifications de procédure suivantes sont équivalentes à:

Procédure calculée_discount (numéro multiplicateur);

Procédure calculée_discount (multiplicateur en nombre);

P. 19-9

Vous pouvez explicitement définir le mode de paramètre en entrant dans, sortie ou dehors après le nom du paramètre formel dans la spécification du sous-programme.

Noter: Appeler un sous-programme qui accepte le réfrigérateur OUT ou OUT, sachez que la valeur est toujours affectée à la valeur, même si le sous-programme lui-même n'enregistre clairement pas la valeur de ce paramètre.

Par exemple, si vous vous référez à l'élément texte sous forme de paramètre valide pour le paramètre formel dans Out Out, la valeur de cet élément après l'exécution du sous-programme est mise à jour, même si le sous-programme lui-même n'est pas exécuté. Cela peut conduire à modifier l'état de l'enregistrement sur modifié et à la saisie de l'enregistrement pour mettre à niveau ou insertion.

Affectation des valeurs par défaut dans les paramètres Vous pouvez affecter la valeur par défaut au paramètre d'entrée dans la déclaration de ce paramètre. Beaucoup de sous-marins Oracle Forms Intégrés utilisent une telle technologie. Lorsque vous appelez de telles sous-programmes, vous n'avez pas besoin d'entrer un paramètre valide pour le paramètre formel par défaut, sauf si vous souhaitez écraser la valeur de paramètre par défaut.

Pour affecter une valeur par défaut au paramètre formel, utilisez l'opérateur d'affectation PL / SQL dans la liste des paramètres formels. La valeur attribuée doit être une constante ou une expression du même type que le paramètre formel:

Procédure calculée_discount (multiplicateur en nombre: \u003d 15);

Appeler cette procédure, vous pouvez paramètre multiplicateur omettez si vous souhaitez que la procédure soit remplie avec la valeur par défaut (15):

calculer_discount;

Ou vous pouvez écraser la valeur par défaut en fournissant un paramètre valide:

calculer_discount (10);

Notez que lors de l'utilisation d'une désignation de position, les valeurs par défaut ne peuvent avoir que les derniers paramètres.

P. 19-10.

Paquets PL / SQL

Le package est la conception PL / SQL, regroupant des types logiquement liés, des objets, des procédures et des fonctions. Les packages ont généralement deux parties - la spécification et le corps, bien que parfois le corps n'est pas nécessaire.

La spécification est l'interface avec le package; Il annonce des types, des variables, des constantes, des exceptions, des curseurs et des sous-programmes (procédures et fonctions) disponibles pour une utilisation. Le corps définit entièrement les curseurs et les sous-routins et effectue la spécification de cette manière.

Oracle Forms vous fournit plusieurs packages prédéfinis à utiliser ou vous pouvez définir dans les modules du formulaire, du menu ou de la bibliothèque vos propres packages. Vous pouvez également définir des packages dans Oracle7Server, puis accéder à leur contenu à partir d'applications logicielles client. Vous trouverez des informations sur l'utilisation de procédures de formulaires Oracle enregistrés dans le chapitre 2 "Procédures enregistrées et Database des déclencheurs" dans Oracle Formes Manuel des techniques avancées.

La syntaxe de paquet est similaire à la procédure:

Le nom du paquet est - Spécification

Type Ads General and Objects

Spécifications des sous-routines

Finir;

Le nom du corps du paquet est - corps (partie cachée)

Type de publicité publique et objets

Sous-routines du corps

Finir;

La spécification contient des annonces générales appliquées à votre programme de candidature. Le corps contient des détails d'exécution et des annonces privées cachées dans votre programme d'application.

Pour votre programme de candidature, seules les annonces sont disponibles dans la spécification du package. Les détails de l'exécution dans le corps de l'emballage sont cachés et non disponibles. Spécification Vous pouvez programmer et compiler séparément. Commmergez la spécification, vous pouvez compiler avec succès des déclencheurs et des sous-routines avec le nom d'utilisateur auquel la spécification fait référence. Vous n'avez pas besoin de définir complètement le corps de l'emballage tant que vous êtes prêt à remplir le programme de candidature.

L'exécution cachée et la définition n'ont que des sous-programmes et des curseurs. Par conséquent, si la spécification ne déclare que des types, des constantes, des variables et des expressions, le corps de l'emballage n'est pas nécessaire.

P. 19-11

Créer des paquets

Vous pouvez créer des packages en organisant vos procédures et vos fonctions pour former une valise d'objets PL / SQL.

Les packages peuvent contenir des variables constantes pour toute la session utilisateur (s'apparente au même utile que la variable globale du côté serveur), ainsi que des curseurs pouvant rester ouverts aux fonctions et procédures d'appel dans l'emballage.

Pour plus d'informations sur les packages, voir PL / SQL Version 2.0 Guide de l'utilisateur et référence.

Exemple:

Créer ou remplacer le paquet lib_hr comme

Fonction GET_SSN (TheMPNO Number) Numéro de retour;

Embauchez un nouvel employé et retournez-le / son numéro de table

numéroDept,

thesalnumber,

date de lutte

thessnnumber) Numéro de retour;

there Saison Varchar2);

Installer une variable de prix

PROCEDURE SET_BONUS (NUMÉRO DE NOUVELLEVALUE);

Fin de lib_hr;

Créer ou remplacer le paquet corps lib_hr comme

Variables de paquet -

signingbonus numéro: \u003d 1000;

Paquet de curseur -

Curseur suivant_empid

SELECT SELECT EMPID_SEFENCE.NEXTVAL

De double;

Supprimer le numéro de protection sociale de l'employé

Fonction GET_SSN (TheMPNO Number) Le numéro de retour est

numéro TMPSSN;

P. 19-12.

Commencer.

Sélectionnez SSN.

Dans tmpsnsn.

De EMP

Où Empno \u003d Theempno;

Retour (TMPSSN);

Exception

Quand no_data_found alors.

Retour (-1);

Finir;

Embaucher un nouvel employé et retourner le numéro de table

Fonction hire_employee (Tuname Varchar2,

numéroDept,

thesalnumber,

date de lutte

thessnnumber) Le numéro de retour est

numéro TMPempno;

Commencer.

Si (pas Next_empid% isopen) alors

Ouvrez NEXT_EMPID;

FIN SI;

Chercher next_empid dans tmpempno;

Nous n'avons pas besoin de fermer le curseur, comme il sera

Rester ouvert entre les défis

Insérer dans EMP (EMPNO, ENAME, DEPTNO, SAL,

hariée, SSN, Bonus)

Valeurs (tmpempno, thuname, tôt, thésal,

thedate, Thessn, Signingbonus);

Retour (tmpempno);

Ecxtion

Quand d'autres alors.

Retour (-1);

Finir;

Tirer un employé existant

Procédure Fire_employee (Numéro Theempno,

ther Saison Varchar2) est

Commencer.

Supprimer de EMP

Où Empno \u003d Theempno;

Insérer dans les terminaisons (EMPNO, RAISON)

Valeurs (Theempno, traitement);

Finir;

P. 19-13.

Installer une variable de prix

Procédure Set_Bonus (Numéro de NewValue) est

Commencer.

signingbonus: \u003d NewValue;

Finir;

Fin de lib_hr;

Noter: Lorsque le paquet est appelé pour la première fois (par n'importe quel utilisateur dans l'instance), puis dans Oracle7 SGA, le package est chargé entièrement, ce qui rend les appels ultérieurs contenus dans les procédures informatiques et fonctionne très rapidement.

RestrictionsOracle Forms fournit une prise en charge directe pour appeler les procédures et fonctions enregistrées, mais pas un accès direct aux variables ou les curseurs de package. Pour manipuler les variables et les curseurs de paquets dans le programme du côté serveur, vous devez construire la procédure ou la fonction. Les types de données admissibles sont:

Varchar2 - Maximum Varchar2 (2000)

Nombre

Date.

Booléen.

Si vous utilisez ces types de données pour écrire des procédures et des fonctions, les valeurs de la variable de package et des données de curseur extraites peuvent être renvoyées par les formulaires Oracle appelant via les paramètres ou la valeur de Fosaless de la fonction.

Oracle Forms exige la spécification et le corps de l'emballage a la possibilité de compiler le bloc de formulaires Oracle PL / SQL, ce qui rend l'accès à ce package.

Appel au contenu du paquet

Vous pouvez accéder au contenu de l'emballage à l'aide de la marque Standard PL / SQL Point:

package_name.Object_name.

package_name.Program_unit_name_name.

Par exemple, appeler la procédure arrangement_windowsdéfini dans le paquet win_manage.Vous pouvez écrire dans la gâchette ou dans le nom du sous-programme pour écrire ce qui suit:

win_manage.arrange_windows

Les mêmes règles d'action sont utilisées pour les emballages qui contactent les sous-routines avec le nom d'utilisateur.

P. 19-14

Forfaits Oracle Forms

Oracle Forms fournit les packages prédéfinis suivants:

Extensions standard	Le package d'extensions standard contient les fonctions et procédures de formulaire Oracle intégrées.
Tool_env	Tool_Env vous permet d'interagir avec des variables Oracle.
Ora_nls.	Le paquet ORA_NLS vous offre la possibilité d'extraire des informations de haut niveau sur votre environnement linguistique.
Tool_Res.	Le package Tool_Res vous permet d'extraire des ressources en chaîne à partir d'un fichier de ressources.
Ora_ffi	Le paquet ORA_FFI permet d'accéder aux fonctions externes (3GL).
Ora_de.	Le package ORA_DE est un package interne. N'utilisez pas ce paquet.
STPROC	STPROC PACK est un forfait interne. N'utilisez pas ce paquet.
Text_io.
Pecs.	Le paquet PECS vous permet d'évaluer les performances du formulaire.
Formulaires_ole.	Le package Forms_ole contient des fonctions OLE Oracle Formes.
	Le package VBX contient les fonctions et procédures VBX Oracle Formes.
Standard.	Le paquet standard contient des fonctions et des procédures PL / SQL.