Mise en cache des messages avec des canaux uniques

Singleton Pipe est un ajout au package 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.

A propos de la mise en cache des messages avec des canaux uniques

Le package DBMS_PIPE a étendu les fonctionnalités sur Autonomous AI Database pour prendre en charge Singleton Pipes.

Un tuyau simple dans DBMS_PIPE :

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. Pour plus d'informations, reportez-vous à DBMS_PIPE dans Oracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference.

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

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

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

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

Description de l'illustration singleton-pipe-workflow.png ci-après

Présentation et caractéristiques de Singleton Pipe

Opérations de tuyauterie simple

Opération Fonction ou Procédure DBMS_PIPE
Créer un singleton explicite Fonction CREATE_PIPE
Mettre en cache un message dans un canal unique

PACK_MESSAGE Procedures dans Oracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference

Fonction SEND_MESSAGE
Lire un message en cache à partir de Singleton Pipe RECEIVE_MESSAGE Function, UNPACK_MESSAGE Procedures dans Oracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference
Supprimer un message dans le canal unique PURGE Procedure dans Oracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference
Suppression d'un canal singleton explicite REMOVE_PIPE Function dans le manuelOracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference

Actualisation automatique du message mis en cache avec une fonction de cache

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 :

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 :

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.

Description de l'image automatic-cache-refresh-cache-function.eps ci-dessous

Description de l'illustration automatic-cache-refresh-cache-function.png ci-après

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 standard d'une fonction de cache sont les suivantes :

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

Créer un singleton explicite

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

Dans cet exemple, créez d'abord la fonction d'aide receive_message pour appeler DBMS_PIPE.RECEIVE_MESSAGE de façon répétée. Cela vous permet de tester la fonctionnalité de canalisation unique.

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. Pack et envoi d'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 à Procédures PACK_MESSAGE dans Oracle Database 19c PL/SQL Packages and Types Reference ou Oracle Database 26ai PL/SQL Packages and Types Reference et Fonction SEND_MESSAGE.

  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;

Création d'un canal unique explicite avec une fonction de cache

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.

Contenu connexe