Mise en cache des messages avec des canaux uniques

Le package DBMS_PIPE dispose de fonctionnalités étendues sur Autonomous Database pour prendre en charge Singleton Pipes.

Un tuyau simple dans DBMS_PIPE :

• Fournit la mise en cache en mémoire des données personnalisées à l'aide des messages Singleton Pipe.

• Prend en charge la possibilité de mettre en cache et de récupérer un message personnalisé de 32 767 octets maximum.

• Prend en charge le partage d'un message mis en cache entre plusieurs sessions de base de données avec des lectures simultanées. Cela fournit un débit élevé et prend en charge les lectures simultanées de messages dans les sessions de base de données.

• Prend en charge les bases de données en lecture seule et en lecture-écriture.

• Prend en charge plusieurs méthodes d'invalidation du cache :

  • Invalidation de cache explicite contrôlée par l'utilisateur.
  • Invalidation du cache après l'intervalle de temps spécifié par l'utilisateur (en secondes). Cette méthode d'invalidation est contrôlée par l'expéditeur du message, à l'aide du paramètre shelflife, et non par les lecteurs de message. Cela évite les pièges courants dus à une utilisation incorrecte du cache par les lecteurs.

A propos des tuyaux standard et des tuyaux simples

Le package DBMS_PIPE permet à plusieurs sessions de base de données de communiquer à l'aide de messages en mémoire. La fonctionnalité Pipe dispose de plusieurs applications telles que l'interface de service externe, le débogage, les transactions indépendantes et les alertes.

Description de l'illustration database-pipe-messages-singleton-pipes.eps

Un canal unique peut être l'un des types DBMS_PIPE pris en charge :

• Tuyau implicite : créé automatiquement lorsqu'un message est envoyé avec un nom de tuyau inconnu à l'aide de la fonction DBMS_PIPE.SEND_MESSAGE.
• Tuyau explicite : créé à l'aide de la fonction DBMS_PIPE.CREATE_PIPE avec un nom de tuyau spécifié par l'utilisateur.
• Public Pipe : accessible par tout utilisateur disposant du droit d'accès EXECUTE sur le package DBMS_PIPE.
• Tuyau privé : accessible par les sessions avec le même utilisateur que le créateur de pipe.

Les singleton Pipes permettent de mettre en cache un seul message dans la mémoire de l'instance Autonomous Database.

L'exemple suivant présente le flux de travail général pour l'utilisation de tubes singleton.

Description de l'exemple singleton-pipe-workflow.eps

Le package DBMS_PIPE vous permet de remplir automatiquement un message Singleton Pipe à l'aide d'une fonction de cache définie par l'utilisateur.

Par défaut, une fois qu'un message est invalidé avec une invalidation explicite ou implicite de Singleton Pipe, une valeur DBMS_PIPE.RECEIVE_MESSAGE suivante n'entraîne aucun message reçu. Pour ajouter un nouveau message au canal, le message doit être explicitement mis en cache en appelant DBMS_PIPE.SEND_MESSAGE. Pour éviter ce cas, où aucun message n'est disponible lorsque vous lisez à partir d'un canal unique, vous pouvez définir une fonction de cache. Avec une fonction de cache définie, la fonction de cache est automatiquement appelée lorsque vous recevez un message dans les scénarios suivants :

• Lorsque le singleton pipe est vide.
• Lorsque le message d'un canal unique n'est pas valide en raison du temps shelflife écoulé.

Pour utiliser une fonction de cache, définissez la fonction de cache et incluez le paramètre cache_func avec DBMS_PIPE.RECEIVE_MESSAGE. Une fonction de cache définie par l'utilisateur fournit les éléments suivants :

• La fonction de cache peut être spécifiée lors de la lecture d'un message à partir d'un canal unique à l'aide de DBMS_PIPE.RECEIVE_MESSAGE.
• Lorsqu'il n'y a aucun message dans le canal unique, DBMS_PIPE.RECEIVE_MESSAGE appelle la fonction de cache.
• Lorsque le temps du message shelflife s'est écoulé, la base de données alimente automatiquement un nouveau message dans le canal unique.

L'utilisation d'une fonction de cache simplifie l'utilisation de singleton pipes. Vous n'avez pas besoin de gérer les cas d'échec pour recevoir un message d'un canal vide. En outre, une fonction de cache garantit qu'il n'y a pas d'échec de cache lorsque vous lisez des messages à partir d'un canal unique, ce qui permet une utilisation maximale du message mis en cache.

Lorsque vous définissez une fonction de cache, le nom de la fonction doit être entièrement qualifié avec le schéma propriétaire :

• OWNER.FUNCTION_NAME
• OWNER.PACKAGE.FUNCTION_NAME

Définissez une fonction de cache avec la signature suivante :

CREATE OR REPLACE FUNCTION cache_function_name(
       pipename  IN VARCHAR2
) RETURN INTEGER;

Les opérations standard d'une fonction de cache sont les suivantes :

• Créez un canal unique, pour un canal explicite, à l'aide de DBMS_PIPE.CREATE_PIPE.
• Créez un message à mettre en cache dans le singleton pipe.
• Envoyez le message au canal indiqué dans la fonction de cache, en spécifiant éventuellement une valeur shelflife pour le message implicite.

Pour utiliser une fonction de cache, l'utilisateur de session en cours qui appelle DBMS_PIPE.RECEIVE_MESSAGE doit disposer des privilèges requis pour exécuter la fonction de cache.

Pour plus d'informations sur la définition d'une fonction de cache, reportez-vous à Fonction RECEIVE_MESSAGE.

Décrit les étapes à suivre pour créer une canalisation unique avec un nom de canalisation spécifié (une canalisation unique explicite).

CREATE OR REPLACE FUNCTION msg_types AS
       TYPE t_rcv_row IS RECORD (c1 VARCHAR2(32767), c2 NUMBER);
       TYPE t_rcv_tab IS TABLE OF t_rcv_row;
END;


CREATE OR REPLACE FUNCTION receive_message(
      pipename    IN VARCHAR2,
      rcv_count   IN NUMBER DEFAULT 1,
      cache_func  IN VARCHAR2 DEFAULT NULL)
   RETURN msg_types.t_rcv_tab pipelined
    AS
       l_msg    VARCHAR2(32767);
       l_status NUMBER;
 BEGIN
      FOR i IN 1..rcv_count LOOP
           l_status := DBMS_PIPE.RECEIVE_MESSAGE(
            pipename   => pipename,
            cache_func => cache_func,
            timeout    => 1);
         IF l_status != 0 THEN
              raise_application_error(-20000,
             'Message not received for attempt: ' || to_char(i) || ' status: ' ||
            l_status);
         END IF;

         DBMS_PIPE.UNPACK_MESSAGE(l_msg);
             pipe row(msg_types.t_rcv_row(l_msg));
     END LOOP;
 RETURN;
 END;

1. Créez un singleton explicite nommé PIPE_TEST avec le paramètre shelflife défini sur 3600 (secondes).

   DECLARE
     l_status INTEGER;
   BEGIN
     l_status := DBMS_PIPE.CREATE_PIPE(
                   pipename => 'MY_PIPE1',
                   private => TRUE,
                   singleton => TRUE,
                   shelflife => 3600);
   END;
   /

   Pour plus d'informations, reportez-vous à Fonction CREATE_PIPE.

2. Vérifiez que le singleton pipe est créé.

   SELECT name, singleton, type
        FROM v$db_pipes WHERE name= '&pipename' ORDER BY 1;
   
   NAME                 SINGLETON  TYPE
   -------------------- ---------- -------
   PIPE_TEST            YES        PRIVATE

3. Emballez et envoyez un message sur le singleton pipe.

   
   EXEC DBMS_PIPE.PACK_MESSAGE('This is a real message that you can get multiple times');
   
   SELECT DBMS_PIPE.SEND_MESSAGE(pipename => '&pipename') status FROM DUAL;
   
   STATUS
   ----------
   0

   Pour plus d'informations, reportez-vous aux sections PACK_MESSAGE Procedures et SEND_MESSAGE Function.

4. Recevoir un message d'un pipeline singleton.

   SELECT * FROM receive_message(
       pipename => '&pipename',
       rcv_count => 2);
   
   MESSAGE
   --------------------------------------------------------------------------------
   This is a real message that you can get multiple times
   This is a real message that you can get multiple times

   La fonction receive_message est une fonction d'aide qui appelle DBMS_PIPE.RECEIVE_MESSAGE.

5. Purgez le message et retirez le pipe.

   EXEC DBMS_PIPE.PURGE('&pipename');
   SELECT DBMS_PIPE.REMOVE_PIPE('&pipename') status FROM DUAL;

Décrit les étapes à suivre pour créer un canal unique avec un nom de canal spécifié, un canal unique explicite, et fournir une fonction de cache. Une fonction de cache vous permet de remplir automatiquement le message dans un canal unique.

1. Créez une fonction de cache, test_cache_message, pour un pipeline singleton.

   CREATE OR REPLACE FUNCTION test_cache_message(
        pipename IN VARCHAR2) return NUMBER 
   AS 
      l_status NUMBER;
      l_data VARCHAR2(4000);
   BEGIN
      l_status := DBMS_PIPE.CREATE_PIPE(
             pipename => pipename,
             private => TRUE,
             singleton => true,
             shelflife => 600);
      IF l_status != 0 THEN RETURN l_status;
      END IF;
    
      DBMS_PIPE.PACK_MESSAGE('This is a placeholder cache message for an empty pipe');
      l_status := DBMS_PIPE.SEND_MESSAGE(pipename => pipename);
      RETURN l_status;
    END;
   /

   Remarque
   
   L'utilisateur de session en cours qui appelle DBMS_PIPE.RECEIVE_MESSAGE doit disposer du privilège requis pour exécuter la fonction de cache.
2. Réception avec une fonction de cache et confirmation du remplissage du message dans le pipe. Le canal doit exister en tant que canal privé créé dans la fonction de cache.

   SELECT * FROM receive_message(
        pipename => '&pipename',
        rcv_count => 1,
        cache_func => 'TEST_CACHE_MESSAGE');
   
   MESSAGE
   ---------------
   This is a placeholder cache message for an empty pipe
   

   La fonction receive_message est une fonction d'aide qui appelle DBMS_PIPE.RECEIVE_MESSAGE. Reportez-vous à Création d'un canal unique explicite pour la définition receive_message.

   Pour plus d'informations, reportez-vous à Fonction CREATE_PIPE.

3. Recevoir sans la fonction de cache pour confirmer que le message persiste dans le canal.

   SELECT * FROM receive_message(
        pipename => '&pipename',
        rcv_count => 2);
   
   MESSAGE
   ---------------
   This is a placeholder cache message for an empty pipe
   This is a placeholder cache message for an empty pipe

   La fonction receive_message est une fonction d'aide qui appelle DBMS_PIPE.RECEIVE_MESSAGE. Reportez-vous à Création d'un canal unique explicite pour la définition receive_message.

   Pour plus d'informations, reportez-vous à Fonction CREATE_PIPE.