Programmation côté serveur : PL/SQL, Java et JavaScript

Le langage SQL explique le langage SQL (Structured Query Language) et comment la base de données traite les instructions SQL. Ce chapitre explique comment les programmes PL/SQL ou Java stockés dans la base de données peuvent utiliser le langage SQL.

Présentation de la programmation côté serveur

Dans un langage non procédural tel que SQL, l'ensemble de données à utiliser est spécifié, mais pas les opérations à effectuer ou la manière dont elles doivent être effectuées.

Dans un programme en langage procédural, l'exécution de la plupart des instructions dépend des instructions précédentes ou suivantes et des structures de contrôle, telles que les boucles ou les branches conditionnelles, qui ne sont pas disponibles en SQL. Pour illustrer la différence entre les langages procéduraux et non procéduraux, supposons que l'instruction SQL suivante interroge la table employees :

SELECT employee_id, department_id, last_name, salary FROM employees;

L'instruction précédente demande des données, mais n'applique pas de logique aux données. En revanche, supposons qu'une application détermine si chaque salarié du jeu de données mérite une augmentation en fonction du salaire et des performances du service. Une condition nécessaire d'une augmentation est que l'employé n'a pas reçu plus de trois augmentations au cours des cinq dernières années. Si une augmentation est demandée, l'application doit ajuster le salaire et envoyer un e-mail au responsable. Sinon, l'application doit mettre à jour un état.

Le problème réside dans la façon dont les applications de base de données procédurales nécessitant une logique conditionnelle et un contrôle de flux de programme peuvent utiliser SQL. Les approches de base du développement sont les suivantes :

Ce chapitre explique la deuxième approche. Le principal avantage de la programmation côté serveur est que les fonctionnalités intégrées à la base de données peuvent être déployées n'importe où. La base de données et non l'application déterminent la meilleure façon d'effectuer des tâches sur un système d'exploitation donné. En outre, les sous-programmes augmentent l'évolutivité en centralisant le traitement des applications sur le serveur, ce qui permet aux clients de réutiliser le code. Etant donné que les appels de sous-programmes sont rapides et efficaces, un seul appel peut démarrer un sous-programme stocké exigeant beaucoup de calcul, ce qui réduit le trafic réseau.

Vous pouvez utiliser les langues suivantes pour stocker la logique de données dans Oracle AI Database :

Voir aussi :

Présentation de PL/SQL

Le langage PL/SQL fournit un langage procédural stocké côté serveur, facile à utiliser et transparent avec SQL, robuste, portable et sécurisé. Vous pouvez accéder aux données de base de données et les manipuler à l'aide d'objets procéduraux appelés unités PL/SQL.

Les unités PL/SQL sont généralement classées comme suit :

Le compilateur et l'interpréteur PL/SQL sont intégrés dans Oracle SQL Developer, ce qui offre aux développeurs un modèle de développement cohérent et exploité sur le client et le serveur. En outre, les procédures stockées PL/SQL peuvent être appelées à partir de plusieurs clients de base de données, tels que Pro*C, JDBC, ODBC ou OCI, et à partir d'Oracle Reports et d'Oracle Forms.

Voir aussi :

Sous-programmes PL/SQL

Un sous-programme PL/SQL est un bloc PL/SQL nommé qui permet à l'appelant de fournir des paramètres qui peuvent être des valeurs d'entrée uniquement, de sortie uniquement ou d'entrée et de sortie.

Un sous-programme résout un problème spécifique ou effectue les tâches associées et sert de bloc de construction pour les applications de base de données modulaires et maintenables. Un sous-programme est une procédure PL/SQL ou une fonction PL/SQL. Les procédures et les fonctions sont identiques, sauf que les fonctions renvoient toujours une seule valeur, contrairement aux procédures. Le terme procédure PL/SQL dans ce chapitre fait référence à une procédure ou à une fonction.

Voir aussi :

Avantages des sous-programmes PL/SQL

La programmation côté serveur présente de nombreux avantages par rapport à la programmation côté client.

Avantages :

Voir aussi :

Création de sous-programmes PL/SQL

Un sous-programme stocké autonome est un sous-programme créé au niveau du schéma avec l'instruction CREATE PROCEDURE ou CREATE FUNCTION. Les sous-programmes définis dans un package sont appelés sous-programmes de package et sont considérés comme faisant partie du package.

La base de données stocke les sous-programmes dans le dictionnaire de données en tant qu'objets de schéma. Un sous-programme a une spécification, qui inclut des descriptions de tous les paramètres et un corps.

Exemple 11-1 Procédure PL/SQL

Cet exemple montre une partie d'une instruction de création pour la procédure PL/SQL autonome hire_employees. La procédure insère une ligne dans la table employees.

CREATE PROCEDURE hire_employees
  (p_last_name VARCHAR2, p_job_id VARCHAR2, p_manager_id NUMBER,
   p_hire_date DATE, p_salary NUMBER, p_commission_pct NUMBER,
   p_department_id NUMBER)
IS
BEGIN
.
.
.
  INSERT INTO employees (employee_id, last_name, job_id, manager_id, hire_date,
    salary, commission_pct, department_id)
  VALUES (emp_sequence.NEXTVAL, p_last_name, p_job_id, p_manager_id,
          p_hire_date, p_salary, p_commission_pct, p_department_id);
.
.
.
END;

Voir aussi :

Exécution de sous-programmes PL/SQL

Les utilisateurs peuvent exécuter un sous-programme de différentes manières de manière interactive.

Les options proposées sont les suivantes :

Le graphique suivant présente différentes applications de base de données appelant hire_employees.

Figure 1 : Exécutions multiples d'une procédure stockée

Description de l'image cncpt073.gif

Un utilisateur privilégié peut également utiliser Oracle Enterprise Manager ou SQL*Plus pour exécuter la procédure hire_employees à l'aide d'une instruction telle que la suivante :

EXECUTE hire_employees ('TSMITH', 'CLERK', 1037, SYSDATE, 500, NULL, 20);

L'instruction précédente insère un nouvel enregistrement pour TSMITH dans la table employees.

Une procédure stockée dépend des objets référencés dans son corps. La base de données suit et gère automatiquement ces dépendances. Par exemple, si vous modifiez la définition de la table employees référencée par la procédure hire_employees d'une manière qui affecterait cette procédure, la procédure doit être recompilée pour vérifier qu'elle fonctionne toujours comme prévu. Généralement, la base de données administre automatiquement cette gestion des dépendances.

Voir aussi :

Packages PL/SQL

Un package PL/SQL est un groupe de sous-programmes liés, avec des curseurs et des variables qu'ils utilisent ; ils sont stockés dans la base de données en tant qu'unité afin d'être utilisés. Les sous-programmes packagés peuvent être appelés explicitement par les applications ou les utilisateurs.

Oracle AI Database inclut de nombreux packages fournis qui étendent les fonctionnalités de base de données et fournissent un accès PL/SQL aux fonctionnalités SQL. Par exemple, le package UTL_HTTP permet aux appels HTTP de PL/SQL et SQL d'accéder à des données sur Internet ou d'appeler des cartouches Oracle Web Server. Vous pouvez utiliser les packages fournis lors de la création d'applications ou en tant que source d'idées lors de la création de vos propres procédures stockées.

Avantages des packages PL/SQL

Les packages PL/SQL offrent un certain nombre d'avantages au développeur d'applications.

Avantages :

Création de packages PL/SQL

Vous créez un package en deux parties : la spécification et le corps. La spécification du package déclare toutes les constructions publiques du package, tandis que le corps du package définit toutes les constructions (publiques et privées) du package.

L'exemple suivant illustre une partie d'une instruction qui crée la spécification de package pour employees_management, qui encapsule plusieurs sous-programmes utilisés pour gérer une base de données d'employés. Chaque partie du package est créée avec une instruction différente.

CREATE PACKAGE employees_management AS
  FUNCTION hire_employees (last_name VARCHAR2, job_id VARCHAR2, manager_id NUMBER,
    salary NUMBER, commission_pct NUMBER, department_id NUMBER) RETURN NUMBER;
  PROCEDURE fire_employees(employee_id NUMBER);
  PROCEDURE salary_raise(employee_id NUMBER, salary_incr NUMBER);
.
.
.
  no_sal EXCEPTION;
END employees_management;

La spécification déclare la fonction hire_employees, les procédures fire_employees et salary_raise, ainsi que l'exception no_sal. Tous ces objets de programme publics sont accessibles aux utilisateurs qui ont accès au package.

L'instruction CREATE PACKAGE BODY définit les objets déclarés dans la spécification. Le corps du package doit être créé dans le même schéma que le package. Après avoir créé le package, vous pouvez développer des applications qui appellent l'une de ces procédures ou fonctions publiques ou qui génèrent l'une des exceptions publiques du package.

Voir aussi : Référence du langage PL/SQL d'Oracle AI Database pour en savoir plus sur l'instruction CREATE PACKAGE

Exécution de sous-programmes de package PL/SQL

Les déclencheurs de base de données, les sous-programmes stockés, les programmes applicatifs 3GL et les outils Oracle peuvent référencer le contenu des packages.

L'illustration suivante présente les applications de base de données qui appellent des procédures et des fonctions dans le package employees_management.

Figure 2 : Appel de sous-programmes dans un package PL/SQL

Description de l'image cncpt075.gif

Les applications de base de données appellent explicitement des procédures packagées si nécessaire. Une fois les privilèges accordés pour le package employees_management, un utilisateur peut exécuter explicitement l'une des procédures qu'il contient. Par exemple, SQL*Plus peut exécuter l'instruction suivante pour exécuter la procédure de package hire_employees :

EXECUTE employees_management.hire_employees ('TSMITH', 'CLERK', 1037, SYSDATE, 500, NULL, 20);

Voir aussi :

Blocs anonymes PL/SQL

Un bloc anonyme PL/SQL est une unité PL/SQL non nommée et non persistante.

Exemples d'utilisation des blocs anonymes :

Les blocs anonymes ne présentent pas les avantages de la réutilisation de code des sous-programmes stockés. Le Table 11-1 récapitule les différences entre les deux types d'unité PL/SQL.

Tableau 1 Différences entre des blocs anonymes et des sous-programmes

Unité PL/SQL : Blocs anonymes Sous-programmes
Vous avez indiqué un nom ? Non Oui
Compilé à chaque réutilisation ? Non Non
Stocké dans la base ? Non Oui
Invocable par d'autres applications ? Non Oui
Peut-on renvoyer des valeurs de variable attachée ? Oui Oui
Capable de renvoyer des valeurs de fonction ? Non Oui
Capable d'accepter des paramètres ? Non Oui

Un bloc anonyme se compose d'une partie déclarative facultative, d'une partie exécutable et d'un ou plusieurs gestionnaires d'exceptions facultatifs. L'exemple de bloc anonyme suivant sélectionne le nom d'un employé dans une variable et affiche le nom :

DECLARE
  v_lname VARCHAR2(25);
BEGIN
  SELECT last_name
    INTO v_lname
  FROM employees
  WHERE employee_id = 101;
  DBMS_OUTPUT.PUT_LINE('Employee last name is '||v_lname);
END;

Oracle AI Database compile le bloc PL/SQL et le place dans la zone de mémoire partagée de la mémoire SGA, mais il ne stocke pas le code source ni la version compilée dans la base de données en vue de sa réutilisation au-delà de l'instance en cours. Contrairement aux déclencheurs, un bloc anonyme est compilé chaque fois qu'il est chargé en mémoire. Le langage SQL partagé permet de réutiliser et de partager des blocs PL/SQL anonymes dans la zone de mémoire partagée jusqu'à ce qu'ils soient supprimés de la zone de mémoire partagée.

Voir aussi : Guide de développement Oracle AI Database pour en savoir plus sur les blocs PL/SQL anonymes

Structures de langage PL/SQL

Les blocs PL/SQL peuvent inclure diverses structures de langage PL/SQL.

Ces constructions incluent les éléments suivants :

Le langage PL/SQL peut exécuter des instructions SQL dynamique dont le texte complet n'est pas connu avant l'exécution. Les instructions SQL dynamiques sont stockées dans des chaînes de caractères qui sont entrées ou créées par le programme lors de l'exécution. Cette technique vous permet de créer des procédures à usage général. Par exemple, vous pouvez créer une procédure qui fonctionne sur une table dont le nom n'est pas connu avant l'exécution.

Voir aussi :

Collections et enregistrements PL/SQL

De nombreuses techniques de programmation utilisent des types de collection tels que des tableaux, des sacs, des listes, des tables imbriquées, des ensembles et des arbres.

Pour prendre en charge les techniques de collecte dans les applications de base de données, le langage PL/SQL fournit les types de données TABLE et VARRAY. Ces types vous permettent de déclarer des tableaux associatifs, des tables imbriquées et des tableaux de taille variable.

Recouvrements

Une collection PL/SQL est un groupe ordonné d'éléments, tous du même type.

Chaque élément dispose d'un sous-script unique qui détermine sa position dans la collection. Pour créer une collection, vous devez d'abord définir un type de collection, puis déclarer une variable de ce type.

Les collections fonctionnent comme les tableaux de la plupart des langages de programmation de troisième génération. En outre, les ensembles peuvent être transmis en tant que paramètres. Vous pouvez donc les utiliser pour déplacer des colonnes de données vers et hors des tables de base de données ou entre des applications côté client et des sous-programmes stockés.

Enregistrements

Un enregistrement PL/SQL est une variable composite pouvant stocker des valeurs de données de différents types, semblable à un type struct dans C, C++ ou Java. Les enregistrements peuvent contenir des données issues de lignes d'une table ou certaines colonnes de lignes d'une table.

Supposons que vous disposiez de données sur un employé, telles que son nom, son salaire et sa date d'embauche. Ces éléments sont de type différent mais logiquement liés. Un enregistrement contenant un champ pour chaque élément vous permet de traiter les données comme une unité logique.

Vous pouvez utiliser l'attribut %ROWTYPE pour déclarer un enregistrement qui représente une ligne ou une ligne de table extraite d'un curseur. Avec les enregistrements définis par l'utilisateur, vous pouvez déclarer vos propres champs.

Voir aussi : Référence du langage PL/SQL d'Oracle AI Database pour apprendre à utiliser les enregistrements PL/SQL

Exécution de PL/SQL

Le langage PL/SQL prend en charge l'exécution interprétée et l'exécution native.

En exécution interprétée, le code source PL/SQL est compilé en une représentation dite de code exécutable. Un ordinateur virtuel portable implémenté dans le cadre d'Oracle AI Database exécute ce code exécutable.

L'exécution native offre les meilleures performances sur les unités à forte intensité de calcul. Dans ce cas, le code source des unités PL/SQL est compilé directement dans le code objet pour la plate-forme donnée. Ce code objet est lié à Oracle AI Database.

Le moteur PL/SQL définit, compile et exécute des unités PL/SQL. Ce moteur est un composant spécial de nombreux produits Oracle, y compris Oracle AI Database. Bien que de nombreux produits Oracle disposent de composants PL/SQL, cette rubrique couvre spécifiquement les unités PL/SQL qui peuvent être stockées dans Oracle AI Database et traitées à l'aide du moteur PL/SQL d'Oracle AI Database. La documentation de chaque outil Oracle décrit ses fonctionnalités PL/SQL.

Le graphique suivant illustre le moteur PL/SQL contenu dans Oracle AI Database.

Figure 3 : Moteur PL/SQL et Oracle AI Database

Description de l'image cncpt070.gif

L'unité PL/SQL est stockée dans une base de données. Lorsqu'une application appelle une procédure stockée, la base de données charge l'unité PL/SQL compilée dans le pool partagé de la zone globale du système (SGA). Les exécuteurs d'instructions PL/SQL et SQL fonctionnent de concert pour traiter les instructions de la procédure.

Vous pouvez appeler une procédure stockée à partir d'un autre bloc PL/SQL, qui peut être un bloc anonyme ou une autre procédure stockée. Par exemple, vous pouvez appeler une procédure stockée à partir d'Oracle Forms.

Une procédure PL/SQL s'exécutant sur Oracle AI Database peut appeler une procédure ou un service externe écrit en langage C et stocké dans une bibliothèque partagée. La routine C s'exécute dans un espace d'adressage distinct de celui d'Oracle AI Database.

Voir aussi :

Présentation de Java dans Oracle AI Database

Java est devenu le langage de programmation orienté objet de choix.

Java inclut les fonctionnalités suivantes :

La base de données fournit aux programmes Java un moteur de traitement de données dynamique qui prend en charge les requêtes complexes et les vues multiples des données. Les demandes client sont assemblées en tant que requêtes de données pour un traitement immédiat. Les résultats de la requête sont générés dynamiquement.

La combinaison de Java et d'Oracle AI Database vous aide à créer des applications basées sur les composants et centrées sur le réseau qui peuvent être facilement mises à jour à mesure que les besoins de l'entreprise évoluent. En outre, vous pouvez déplacer des applications et des banques de données hors du bureau et sur des réseaux intelligents et des serveurs centrés sur le réseau. Plus important encore, vous pouvez accéder à ces applications et banques de données à partir de n'importe quel périphérique client.

La figure suivante présente une configuration client/serveur à deux niveaux classique dans laquelle les clients appellent des procédures stockées Java de la même manière qu'ils appellent des sous-programmes PL/SQL.

Figure 4 : Configuration client/serveur à deux niveaux

Description de l'image cncpt236.gif

Présentation du service Java Virtual Machine (JVM)

Un JVM est un processeur virtuel qui exécute le code Java compilé.

Le code source Java est compilé en instructions de machine de bas niveau, appelées bytecodes, qui sont indépendantes de la plate-forme. Les codes exécutables Java sont interprétés via la JVM en actions dépendantes de la plate-forme.

Présentation d'Oracle JVM

La JVM Oracle est un environnement standard compatible Java qui exécute n'importe quelle application Java pure. Il est compatible avec les spécifications JLS et JVM.

La JVM Oracle prend en charge les API et le format binaire Java standard. En outre, Oracle AI Database adhère à la sémantique standard du langage Java, y compris le chargement dynamique des classes lors de l'exécution.

La figure suivante illustre comment les applications Oracle Java résident sur les bibliothèques de classes principales Java, qui résident sur la JVM Oracle. Etant donné que le système de prise en charge Oracle Java est situé dans la base de données, la JVM interagit avec les bibliothèques de base de données au lieu d'interagir directement avec le système d'exploitation.

Figure 5 : Structure des composants Java

Description de l'image cncpt206.gif

Contrairement aux autres environnements Java, Oracle JVM est intégré à Oracle AI Database. Il existe des différences importantes entre la JVM Oracle et les JVM client standard. Par exemple, dans un environnement Java standard, vous exécutez une application Java via l'interpréteur en exécutant la commande suivante sur la ligne de commande, où classname est le nom de la classe que la JVM interprète en premier :

java classname

La commande précédente entraîne l'exécution de l'application dans un processus de votre système d'exploitation. Toutefois, si vous n'utilisez pas l'interface de ligne de commande, vous devez charger l'application dans la base de données, la publier, puis l'exécuter dans un dictionnaire de données de base de données.

Voir aussi : reportez-vous au Guide du développeur Oracle AI Database Java pour obtenir une description des autres différences entre la JVM Oracle et les JVM client standard

Principaux composants d'Oracle JVM

La JVM Oracle s'exécute dans le même espace de processus et d'adressage que le noyau de base de données en partageant ses portions de mémoire et en accédant directement à ses données relationnelles. Cette conception optimise l'utilisation de la mémoire et augmente le débit.

La JVM Oracle fournit un environnement d'exécution pour les objets Java. Il prend entièrement en charge les structures de données Java, la répartition des méthodes, la gestion des exceptions et les threads au niveau du langage. Il prend également en charge toutes les bibliothèques de classes Java principales, notamment java.lang, java.io, java.net, java.math et java.util.

L'illustration suivante présente les principaux composants d'Oracle JVM.

Figure 6 : Principaux composants d'Oracle JVM

Description de l'image cncpt254.gif

La JVM Oracle intègre l'espace de noms Java standard dans les schémas de base de données. Cette fonctionnalité permet aux programmes Java d'accéder aux objets Java stockés dans Oracle AI Database et aux serveurs d'applications dans toute l'entreprise.

En outre, la JVM Oracle est étroitement intégrée à l'architecture de mémoire partagée évolutive de la base de données. Les programmes Java utilisent efficacement les durées de vie des appels, des sessions et des objets sans intervention de l'utilisateur. Par conséquent, les objets métier Java Oracle JVM et de niveau intermédiaire peuvent être redimensionnés, même s'ils présentent un état de session long.

Voir aussi : Guide du développeur Oracle AI Database Java pour une description des principaux composants d'Oracle JVM

Environnement de programmation Java

Oracle fournit aux développeurs d'applications d'entreprise une solution Java de bout en bout pour la création, le déploiement et la gestion d'applications Java.

La solution se compose d'interfaces programmatiques côté client et côté serveur, d'outils pour prendre en charge le développement Java et d'une Java Virtual Machine intégrée à Oracle AI Database. Tous ces produits sont compatibles avec les normes Java.

L'environnement de programmation Java comprend les fonctionnalités supplémentaires suivantes :

Procédures stockées en Java

Une procédure stockée Java est une méthode Java publiée dans SQL et stockée dans la base de données.

A l'instar d'un sous-programme PL/SQL, une procédure Java peut être appelée directement avec des produits tels que SQL*Plus ou indirectement avec un déclencheur. Vous pouvez y accéder à partir de n'importe quel client Oracle Net OCI, précompilateur ou JDBC.

Pour publier des méthodes Java, vous écrivez des spécifications d'appel qui mettent en correspondance les noms de méthode Java, les types de paramètre et les types de retour avec leurs homologues SQL. Lorsqu'elle est appelée par des applications client, une procédure stockée Java peut accepter des arguments, référencer des classes Java et renvoyer des valeurs de résultat Java.

Applications appelant la méthode Java en référençant le nom de la spécification d'appel. Le système d'exécution recherche la définition de spécification d'appel dans le dictionnaire de données Oracle et exécute la méthode Java correspondante.

En outre, vous pouvez utiliser Java pour développer des programmes puissants indépendamment du langage PL/SQL. Oracle AI Database fournit une implémentation entièrement conforme du langage de programmation Java et de la JVM.

Voir aussi : Guide du développeur Java d'Oracle AI Database explique comment écrire des procédures stockées dans Java, comment y accéder à partir de PL/SQL et comment accéder à des fonctionnalités PL/SQL à partir de Java

Intégration Java et PL/SQL

Vous pouvez appeler des programmes PL/SQL existants à partir de programmes Java et Java à partir de PL/SQL. Cette solution protège et exploite votre code PL/SQL et Java.

Oracle AI Database offre JDBC pour accéder aux données SQL à partir de Java sur le client et le serveur.

Pilotes JDBC

JDBC est un protocole d'accès à la base de données qui vous permet de vous connecter à une base de données et d'exécuter des instructions SQL et des requêtes à la base de données.

Les bibliothèques de classes Java principales fournissent une seule API JDBC, java.sql. Cependant, JDBC est conçu pour permettre aux fournisseurs de fournir des pilotes qui offrent la spécialisation nécessaire pour une base de données particulière. Oracle fournit les pilotes JDBC distincts indiqués dans le tableau suivant.

Tableau 2 Pilotes JDBC

Pilote Description
Le pilote JDBC Thin Vous pouvez utiliser le pilote JDBC Thin pour écrire des applications et des applets Java purs qui accèdent aux données Oracle SQL. Le pilote JDBC Thin est particulièrement adapté aux applications et applets Web, car vous pouvez le télécharger dynamiquement à partir d'une page Web, comme n'importe quel autre applet Java.
Pilote OCI JDBC Le pilote OCI JDBC accède au code natif propre à Oracle, c'est-à-dire au code non Java et aux bibliothèques sur le client ou le niveau intermédiaire, ce qui améliore les performances par rapport au pilote léger JDBC, au prix d'une taille nettement plus importante et d'une installation côté client.
Pilote interne côté serveur JDBC Oracle AI Database utilise le pilote interne côté serveur lorsque le code Java s'exécute sur le serveur. Elle permet aux applications Java exécutées dans la JVM Oracle sur le serveur d'accéder aux données définies localement, c'est-à-dire aux données du même système et du même processus, avec JDBC. Il améliore les performances en raison de sa capacité à utiliser directement les bibliothèques de SGBDR Oracle sous-jacentes, sans la surcharge d'une connexion réseau intermédiaire entre le code Java et les données SQL. En prenant en charge la même interface Java-SQL sur le serveur, Oracle AI Database ne vous oblige pas à réutiliser le code lors du déploiement.

Voir aussi :

Présentation de JavaScript dans Oracle AI Database

JavaScript est l'un des langages de programmation les plus populaires aujourd'hui. Oracle AI Database déployé sur Linux x86-64 ou Linux aarch64 ajoute JavaScript à la liste des langages pris en charge pour le développement côté serveur.

Vous pouvez stocker les modules de JavaScript dans la base de données, en traitant les données là où elles se trouvent, ce qui offre des améliorations potentiellement significatives par rapport aux approches de développement côté client. JavaScript est exécuté par Multilingual Engine (MLE).

Les développeurs ont le choix entre exécuter du code JavaScript autonome et stocker le code JavaScript de manière native dans la base de données en tant que modules.

Stockage de la logique métier en tant que modules dans la base de données

Tout comme avec JavaScript lié au développement côté client, le code peut être stocké ensemble sous la forme d'un module.

Les développeurs avec un arrière-plan PL/SQL peuvent considérer un module JavaScript comme l'équivalent d'un corps de package PL/SQL, mais écrit en JavaScript. Les fonctions déclarées dans un module peuvent être marquées pour être exportées ou maintenues privées.

JavaScript dans Oracle AI Database respecte la norme ECMAScript 2023 et offre aux développeurs un large éventail de possibilités de stockage de la logique métier dans la base de données.

Remarque :

Reportez-vous également aux sections suivantes :

Voici un exemple de création d'un module JavaScript avec MLE :

create mle module if not exists example_module
language javascript as

export function string2obj(inputString) {
   if ( inputString === undefined ) {
      throw `must provide a string in the form of key1=value1;...;keyN=valueN`;
   }

   let myObject = {};
   if ( inputString.length === 0 ) {
      return myObject;
   }

   const kvPairs = inputString.split(";");
   kvPairs.forEach( pair => {
      const tuple = pair.split("=");
      if ( tuple.length === 1 ) {
          tuple[1] = false;
      } else if ( tuple.length != 2 ) {
          throw "parse error: you need to use exactly one '=' between key and value and not use '=' in either key or value";
      }
      myObject[tuple[0]] = tuple[1];
  });

  return myObject;
}
/

Le module JavaScript, également appelé module MLE, est désormais stocké dans le schéma de l'utilisateur. Sa seule fonction, string2obj(), peut être exposée au langage SQL et au langage PL/SQL en créant une spécification d'appel. Les spécifications d'appel sont des unités de programme PL/SQL qui vous permettent d'appeler du code JavaScript partout où SQL et PL/SQL peuvent être appelés. La spécification d'appel pour string2obj() peut être écrite comme suit :

create function if not exists p_string_to_JSON(p_str varchar2) return JSON
as mle module example_module
   signature 'string2obj(string)';
/

Une fois la fonction créée, elle peut être appelée à partir de SQL :

declare
   l_json   JSON;
   l_string VARCHAR2(100);
begin
   l_string := 'a=1;b=2;c=3;d';
   l_json := p_string_to_JSON(l_string);
   dbms_output.put_line(json_serialize(l_json PRETTY));
end;
/

{
  "a" : "1",
  "b" : "2",
  "c" : "3",
  "d" : false
}

PL/SQL procedure successfully completed.

Exécution dynamique du code JavaScript

Les développeurs Framework et toute personne souhaitant exécuter du code JavaScript autonome sans avoir à stocker le code dans la base de données peuvent utiliser le package DBMS_MLE et ses sous-programmes.

Oracle Application Express et Database Actions, par exemple, intègrent DBMS_MLE, masquant le fait qu'un package PL/SQL est appelé sous les couvertures.

Par rapport aux modules MLE, l'utilisation de DBMS_MLE rend plus difficile l'écriture d'applications entières. Par exemple, il est plus difficile de diviser logiquement une application en entités distinctes. La fonctionnalité de débogage après exécution nécessite des modules, ce qui rend plus difficile la résolution des problèmes dans les fragments de code. Les pipelines d'intégration continue (CI) peuvent également avoir du mal à peloter du code PL/SQL et JavaScript dans le même fichier. De même, votre environnement de développement intégré (IDE) peut présenter un problème, car la plupart d'entre eux auront du mal à travailler avec PL/SQL et JavaScript dans la même fenêtre.

Remarque :

Reportez-vous également aux sections suivantes :

Procédures stockées en ligne JavaScript

Les spécifications d'appel MLE incorporées intègrent le code JavaScript directement dans les instructions LDD CREATE FUNCTION et CREATE PROCEDURE.

Si vous voulez implémenter rapidement des fonctionnalités simples à l'aide de JavaScript, les spécifications d'appel MLE intégrées peuvent être un bon choix. Avec cette option, vous n'avez pas besoin de déployer un module distinct contenant le code JavaScript. La fonction JavaScript est plutôt intégrée à la définition de la spécification d'appel elle-même.

La clause MLE LANGUAGE permet d'indiquer que la fonction est implémentée à l'aide de JavaScript. La chaîne qui suit le nom de langue est traitée comme le corps d'une fonction JavaScript qui implémente la fonctionnalité de la spécification d'appel. Lorsque le code est exécuté, les paramètres PL/SQL sont automatiquement convertis au type JavaScript par défaut et transmis à la fonction JavaScript en tant que paramètres du même nom. Les noms de paramètre non entre guillemets sont mis en correspondance avec des noms JavaScript majuscules. La valeur renvoyée par une fonction JavaScript est convertie au type de retour de la spécification d'appel PL/SQL, tout comme pour les spécifications d'appel des modules MLE.

Remarque :

Reportez-vous également aux sections suivantes :

Présentation des déclencheurs

Un déclencheur de base de données est une unité de programme stockée compilée, écrite en langage PL/SQL, Java ou JavaScript, qu'Oracle Database appelle ("exécute") automatiquement dans certaines situations.

Un déclencheur se déclenche chaque fois que l'une des opérations suivantes se produit :

  1. Instructions DML sur une table ou une vue particulière, émises par un utilisateur

    Les instructions LMD modifient les données des objets de schéma. Par exemple, l'insertion et la suppression de lignes sont des opérations LMD.

  2. Instructions DDL émises par un utilisateur particulier ou par tout utilisateur

    Les instructions LDD définissent des objets de schéma. Par exemple, la création d'une table et l'ajout d'une colonne sont des opérations LDD.

  3. Evénements de base de données

    La connexion ou la déconnexion utilisateur, les erreurs et le démarrage ou l'arrêt de la base de données sont des événements qui peuvent appeler des déclencheurs.

Les déclencheurs sont des objets de schéma similaires aux sous-programmes, mais qui diffèrent par leur mode d'appel. Un sous-programme est exécuté explicitement par un utilisateur, une application ou un déclencheur. Les déclencheurs sont implicitement appelés par la base de données lorsqu'un événement déclencheur se produit.

Voir aussi :

Avantages des déclencheurs

L'utilisation correcte des déclencheurs vous permet de créer et de déployer des applications plus robustes et qui utilisent la base de données plus efficacement.

Vous pouvez utiliser des déclencheurs pour :

Vous pouvez utiliser des déclencheurs pour appliquer des règles métier de bas niveau communes à toutes les applications client. Par exemple, plusieurs applications peuvent accéder à la table employees. Si un déclencheur de cette table garantit le format des données insérées, cette logique métier n'a pas besoin d'être reproduite dans chaque client. Etant donné que le déclencheur ne peut pas être contourné par l'application, la logique métier du déclencheur est utilisée automatiquement.

Vous pouvez utiliser à la fois des déclencheurs et des contraintes d'intégrité pour définir et appliquer tout type de règle d'intégrité. Cependant, Oracle recommande vivement d'utiliser uniquement des déclencheurs pour appliquer des règles métier complexes non définissables à l'aide d'une contrainte d'intégrité.

L'utilisation excessive de déclencheurs peut entraîner des interdépendances complexes qui peuvent être difficiles à gérer dans une application volumineuse. Par exemple, lorsqu'un déclencheur est appelé, une instruction SQL dans son action de déclencheur peut potentiellement déclencher d'autres déclencheurs, ce qui entraîne des déclencheurs en cascade pouvant produire des effets inattendus.

Voir aussi :

automatiquement dans certaines situations.")

Types de déclencheur

Les déclencheurs peuvent être classés en fonction de leur moyen d'appel et du type d'action qu'ils effectuent.

Oracle Database prend en charge les types de déclencheur suivants :

Voir aussi :

automatiquement dans certaines situations.")

Calendrier des déclencheurs

Vous pouvez définir la synchronisation du déclencheur, que l'action de déclencheur soit exécutée avant ou après l'instruction de déclenchement.

Un déclencheur simple est un déclencheur unique sur une table qui vous permet de spécifier des actions pour exactement l'un des points de temporisation suivants :

Pour les déclencheurs d'instruction et de ligne, un déclencheur BEFORE peut améliorer la sécurité et activer les règles métier avant d'apporter des modifications à la base de données. Le déclencheur AFTER est idéal pour la journalisation des actions.

Un déclencheur composite peut être exécuté à plusieurs points dans le temps. Les déclencheurs composés aident à programmer une approche dans laquelle les actions que vous implémentez pour différents points de synchronisation partagent des données communes.

Voir aussi : Référence du langage PL/SQL d'Oracle AI Database pour en savoir plus sur les déclencheurs composés

automatiquement dans certaines situations.")

Création de déclencheurs

L'instruction CREATE TRIGGER crée ou remplace un déclencheur de base de données.

Un déclencheur PL/SQL présente la forme syntaxique générale suivante :

CREATE TRIGGER trigger_name
  triggering_statement
  [trigger_restriction]
BEGIN
 triggered_action;
END;

Un déclencheur PL/SQL comprend les composants de base suivants :

Voir aussi :

automatiquement dans certaines situations.")

Exemple : instruction CREATE TRIGGER

Cet exemple crée un déclencheur qui se déclenche lorsqu'une instruction INSERT, UPDATE ou DELETE s'exécute sur une table de lignes de revenu.

Supposons que vous créez les tables orders et lineitems avec les instructions suivantes. La table orders contient une ligne pour chaque commande unique, tandis que la table lineitems contient une ligne pour chaque élément d'une commande.

CREATE TABLE orders
( order_id NUMBER PRIMARY KEY,
  /* other attributes */
  line_items_count NUMBER DEFAULT 0 );

CREATE TABLE lineitems
( order_id REFERENCES orders,
  seq_no   NUMBER,
  /* other attributes */
  CONSTRAINT lineitems PRIMARY KEY(order_id,seq_no) );

L'instruction suivante crée un exemple de déclencheur qui met automatiquement à jour la table orders avec le nombre d'éléments dans un ordre :

CREATE OR REPLACE TRIGGER lineitems_trigger
  AFTER INSERT OR UPDATE OR DELETE ON lineitems
  FOR EACH ROW
BEGIN
  IF (INSERTING OR UPDATING)
  THEN
    UPDATE orders SET line_items_count = NVL(line_items_count,0)+1
    WHERE order_id = :new.order_id;
  END IF;
  IF (DELETING OR UPDATING)
  THEN
    UPDATE orders SET line_items_count = NVL(line_items_count,0)-1
    WHERE order_id = :old.order_id;
  END IF;
END;
/

Dans lineitems_trigger, l'instruction de déclenchement est INSERT, UPDATE ou DELETE sur la table lineitems. Il n'existe aucune restriction de déclenchement. Le déclencheur est appelé pour chaque ligne modifiée. Le déclencheur a accès aux anciennes et nouvelles valeurs de colonne de la ligne en cours affectée par l'instruction de déclenchement. Deux noms de corrélation existent pour chaque colonne de la table en cours de modification : l'ancienne valeur (:old) et la nouvelle valeur (:new). Si une session met à jour ou insère des lignes dans lineitems pour une commande, le déclencheur calcule le nombre d'éléments dans cette commande après l'action et met à jour la table orders avec le nombre.

Exemple : Appel d'un déclencheur au niveau ligne

Dans ce scénario, un client lance deux commandes et ajoute et supprime des lignes de détail des commandes.

Le scénario est basé sur le déclencheur créé dans l'exemple : instruction CREATE TRIGGER.

Tableau 3 - Scénario de déclencheur au niveau ligne

Instruction SQL Instruction SQL déclenchée Description 
SQL> INSERT INTO orders
 (order_id) VALUES (78);

  1 row created.
 

Le client crée une commande portant l'ID 78. A ce stade, le client n'a aucun article dans la commande.

Aucune action n'étant exécutée sur la table lineitems, le déclencheur n'est pas appelé. 

SQL> INSERT INTO orders
 (order_id) VALUES (92);

  1 row created.
 

Le client crée une commande distincte portant l'ID 92. A ce stade, le client n'a aucun article dans la commande.

Aucune action n'étant exécutée sur la table lineitems, le déclencheur n'est pas appelé. 

SQL> INSERT INTO lineitems
  (order_id, seq_no)
 VALUES (78,1);

  1 row created. 
UPDATE orders
  SET line_items_count =
  NVL(NULL,0)+1
 WHERE order_id = 78;

Le client ajoute un article pour la commande 78.

INSERT appelle le déclencheur. Le relevé déclenché fait passer le nombre de lignes de la commande 78 de 0 à 1. 

SQL> INSERT INTO lineitems
  (order_id, seq_no)
  VALUES (78,2);

  1 row created. 
UPDATE orders
  SET line_items_count =
  NVL(1,0)+1
 WHERE order_id = 78;

Le client ajoute un article supplémentaire à la commande 78.

INSERT appelle le déclencheur. Le relevé déclenché fait passer le nombre de lignes détail de la commande 78 de 1 à 2. 

SQL> SELECT * FROM orders;

  ORDER_ID LINE_ITEMS_COUNT
 --------- ----------------
 78 2
 92 0
   Le client interroge le statut des deux commandes. La commande 78 contient deux articles. La commande 92 ne contient aucun article. 
SQL> SELECT * FROM lineitems;

  ORDER_ID SEQ_NO
 ---------- ----------
 78 1
 78 2
   Le client interroge le statut des lignes. Chaque article est identifié de manière unique par l'ID de commande et le numéro de séquence. 
SQL> UPDATE lineitems
  SET order_id = 92;

  2 rows updated.
 
UPDATE orders
  SET line_items_count =
  NVL(NULL,0)+1
 WHERE order_id = 92;

  UPDATE orders
  SET line_items_count =
  NVL(2,0)-1
 WHERE order_id = 78; 
UPDATE orders
  SET line_items_count =
  NVL(1,0)+1
 WHERE order_id = 92;

  UPDATE orders
  SET line_items_count =
  NVL(1,0)-1
 WHERE order_id = 78;

Le client déplace les lignes en commande 78 vers la commande 92.

L'instruction UPDATE modifie 2 lignes dans les tables lineitems, ce qui appelle le déclencheur une fois pour chaque ligne.

Chaque fois que le déclencheur est appelé, les deux conditions IF du déclencheur sont remplies. La première condition incrémente le nombre pour l'ordre 92, tandis que la deuxième condition diminue le nombre pour l'ordre 78. Par conséquent, quatre instructions UPDATE au total sont exécutées. 

SQL> SELECT * FROM orders;

  ORDER_ID LINE_ITEMS_COUNT
 --------- ----------------
 78 0
 92 2
   Le client interroge le statut des deux commandes. L'effet net est que le nombre de lignes pour la commande 92 est passé de 0 à 2, tandis que le nombre pour la commande 78 est passé de 2 à 0. 
SQL> SELECT * FROM lineitems;

  ORDER_ID SEQ_NO
 ---------- ----------
 92 1
 92 2
   Le client interroge le statut des lignes. Chaque article est identifié de manière unique par l'ID de commande et le numéro de séquence. 
SQL> DELETE FROM lineitems;

  2 rows deleted.
 
UPDATE orders
  SET line_items_count =
  NVL(2,0)-1
 WHERE order_id = 92;

  UPDATE orders
  SET line_items_count =
  NVL(1,0)-1
 WHERE order_id = 92;

Le client supprime désormais toutes les lignes de toutes les commandes.

L'instruction DELETE modifie 2 lignes dans les tables lineitems, ce qui appelle le déclencheur une fois pour chaque ligne. Pour chaque appel de déclencheur, une seule condition IF du déclencheur est remplie. Chaque fois que la condition diminue le nombre pour l'ordre 92 de 1. Par conséquent, deux instructions UPDATE au total sont exécutées. 

SQL> SELECT * FROM orders;

  ORDER_ID LINE_ITEMS_COUNT
 --------- ----------------
 78 0
 92 0

  SQL> SELECT * FROM lineitems;

  no rows selected
  

Le client interroge le statut des deux commandes. Aucune des deux commandes ne contient de lignes.

Le client interroge également le statut des lignes. Aucun article n'existe.

Exécution de déclencheurs

Oracle Database exécute un déclencheur en interne en suivant les mêmes étapes que pour l'exécution de sous-programmes.

La seule différence subtile est qu'un compte utilisateur a le droit de déclencher un déclencheur s'il a le privilège d'exécuter l'instruction de déclenchement. A cette exception près, la base de données valide et exécute les déclencheurs de la même manière que les sous-programmes stockés.

Voir aussi : Référence du langage PL/SQL d'Oracle AI Database pour en savoir plus sur l'exécution des déclencheurs

automatiquement dans certaines situations.")

Stockage des déclencheurs

Oracle Database stocke les déclencheurs PL/SQL sous forme compilée dans un schéma de base de données, tout comme les procédures stockées PL/SQL.

Lorsqu'une instruction CREATE TRIGGER est validée, le code PL/SQL compilé est stocké dans la base de données. La zone de mémoire partagée supprime le code source du déclencheur PL/SQL.

Le graphique suivant présente une application de base de données avec des instructions SQL qui appellent implicitement des déclencheurs PL/SQL. Les déclencheurs sont stockés séparément de leurs tables associées.

Figure 7 : Déclencheurs

Description de l'image cncpt076.gif

Les déclencheurs Java sont stockés de la même manière que les déclencheurs PL/SQL. Cependant, un déclencheur Java fait référence au code Java compilé séparément avec une instruction CALL. Par conséquent, la création d'un déclencheur Java implique la création de code Java et de ce déclencheur qui fait référence à ce code Java.

Voir aussi : Référence du langage PL/SQL d'Oracle AI Database pour en savoir plus sur la compilation et le stockage des déclencheurs

automatiquement dans certaines situations.")