Mettre en cache des messages à l'aide de canaux singletons

L'ensemble DBMS_PIPE offre des fonctionnalités étendues sur Autonomous AI Database pour la prise en charge de Singleton Pipes.

Un tuyau Singleton dans DBMS_PIPE :

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

• Prend en charge la possibilité de mettre en cache et d'extraire un message personnalisé d'un maximum de 32 767 octets.

• 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 entre 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 de cache :

  • Invalidation explicite du cache contrôlée par l'utilisateur.
  • Invalidation du cache après un 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, plutôt que par les lecteurs de message. Cela évite les pièges courants dus à une utilisation incorrecte du cache par les lecteurs.

À propos des tuyaux standard et des tuyaux Singleton

L'ensemble DBMS_PIPE permet à deux sessions de base de données ou plus de communiquer à l'aide de messages en mémoire. La fonctionnalité de canal comporte 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 tuyau Singleton peut être l'un des types DBMS_PIPE pris en charge :

• Canal implicite : Créé automatiquement lorsqu'un message est envoyé avec un nom de canal inconnu à l'aide de la fonction DBMS_PIPE.SEND_MESSAGE.
• Canal explicite : Créé à l'aide de la fonction DBMS_PIPE.CREATE_PIPE avec un nom de canal spécifié par l'utilisateur.
• Public Pipe : Accessible par tout utilisateur disposant de l'autorisation EXECUTE sur l'ensemble DBMS_PIPE.
• Canal privé : Accessible par des sessions avec le même utilisateur que le créateur du canal.

Les pipets Singleton permettent de mettre en mémoire cache un seul message dans la mémoire de l'instance de base de données Autonomous AI Database.

Voici le flux de travail général pour l'utilisation des tuyaux singleton.

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

L'ensemble DBMS_PIPE vous permet d'alimenter automatiquement un message de canal Singleton à l'aide d'une fonction de mémoire 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, DBMS_PIPE.RECEIVE_MESSAGE suivant n'entraîne aucune réception de message. Pour ajouter un nouveau message à la barre verticale, le message doit être mis en cache explicitement en appelant DBMS_PIPE.SEND_MESSAGE. Pour éviter ce cas, où aucun message n'est disponible lorsque vous lisez à partir d'un canal Singleton, vous pouvez définir une fonction de cache. Lorsqu'une fonction de cache est définie, elle est automatiquement appelée lorsque vous recevez un message dans les scénarios suivants :

• Lorsque le tuyau Singleton est vide.
• Lorsque le message dans une barre verticale Singleton n'est pas valide en raison du temps shelflife écoulé.

Pour utiliser une fonction de mémoire cache, définissez la fonction de mémoire 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 Singleton à l'aide de DBMS_PIPE.RECEIVE_MESSAGE.
• Lorsqu'il n'y a aucun message dans le tuyau Singleton, DBMS_PIPE.RECEIVE_MESSAGE appelle la fonction de cache.
• Lorsque la durée du message shelflife est écoulée, la base de données alimente automatiquement un nouveau message dans la barre verticale Singleton.

L'utilisation d'une fonction de cache simplifie le travail avec Singleton Pipes. Vous n'avez pas besoin de gérer les cas d'échec pour recevoir un message d'un tuyau vide. En outre, une fonction de cache garantit qu'il n'y a pas d'absence de cache lorsque vous lisez des messages à partir d'un canal Singleton, ce qui garantit 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 typiques d'une fonction de cache sont les suivantes :

• Créez un tuyau Singleton, pour un tuyau explicite, à l'aide de DBMS_PIPE.CREATE_PIPE.
• Créez un message à mettre en cache dans le canal Singleton.
• Envoyez le message au canal spécifié dans la fonction de mémoire cache, en spécifiant éventuellement shelflife pour le message implicite.

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

Voir Fonction RECEIVE_MESSAGE pour plus d'informations sur la définition d'une fonction de mémoire cache.

Décrit les étapes de création d'un tuyau Singleton avec un nom de tuyau spécifié (un tuyau Singleton 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 une canalisation singleton explicite nommée PIPE_TEST avec le paramètre shelflife réglé à 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, voir Fonction CREATE_PIPE.

2. Vérifiez que le tuyau singleton 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 tuyau singleton.

   
   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, voir Procédures PACK_MESSAGE et Fonction SEND_MESSAGE.

4. Recevez un message d'une pipe 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. Épurez le message et supprimez le tuyau.

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

Décrit les étapes de création d'un canal Singleton avec un nom de canal spécifié, un canal Singleton explicite et fournit une fonction de cache. Une fonction de cache vous permet d'alimenter automatiquement le message dans une canalisation singleton.

1. Créez une fonction de cache, test_cache_message pour une canalisation 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;
   /

   Note
   
   L'utilisateur de la session courante qui appelle DBMS_PIPE.RECEIVE_MESSAGE doit disposer des privilèges requis pour exécuter la fonction de mémoire cache.
2. Recevoir avec une fonction de cache et confirmer que le message est alimenté dans une barre verticale. 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. Voir Créer un tuyau Singleton explicite pour la définition receive_message.

   Pour plus d'informations, voir Fonction CREATE_PIPE.

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

   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. Voir Créer un tuyau Singleton explicite pour la définition receive_message.

   Pour plus d'informations, voir Fonction CREATE_PIPE.