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

Singleton Pipe est un ajout à l'ensemble DBMS_PIPE qui vous permet de mettre en cache et d'extraire un message personnalisé et de partager le message entre plusieurs sessions de base de données avec des lectures simultanées.

À propos de la mise en mémoire cache des messages avec des canalisations Singleton

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 :

À 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. Pour plus d'informations, voir DBMS_PIPE dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai.

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

Un tuyau Singleton peut être l'un des types DBMS_PIPE pris en charge :

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.png

Présentation et caractéristiques de Singleton Pipe

Opérations de tuyauterie Singleton

Opération Fonction ou procédure DBMS_PIPE
Créer un tuyau Singleton explicite Fonction CREATE_PIPE
Mettre en cache un message dans Singleton Pipe

Procédures PACK_MESSAGE dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai

Fonction SEND_MESSAGE
Lire un message en cache de Singleton Pipe Fonction RECEIVE_MESSAGE, Procédures UNPACK_MESSAGE dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai
Supprimer un message dans Singleton Pipe Procédure PURGE dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai
Supprimer un tuyau singleton explicite Fonction REMOVE_PIPE dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai

Actualisation automatique du message en mémoire cache avec une fonction de mémoire cache

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 :

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 :

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.

Une description de automatic-cache-refresh-cache-function.eps suit

Description de l'illustration automatic-cache-refresh-cache-function.png

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

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 :

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 RECIEVE_MESSAGE pour plus d'informations sur la définition d'une fonction de mémoire cache.

Créer un tuyau Singleton explicite

Décrit les étapes de création d'un tuyau Singleton avec un nom de tuyau spécifié (un tuyau Singleton explicite).

Tout d'abord, pour cet exemple, créez la fonction d'aide receive_message pour appeler DBMS_PIPE.RECEIVE_MESSAGE de manière répétée. Cela vous permet de tester la fonctionnalité de tuyau singleton.

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 dans Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 19c ou Informations de référence sur les ensembles et les types PL/SQL pour Oracle Database 26ai 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;

Créer un canal Singleton explicite avec une fonction Cache

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.

Contenu connexe