Das Package DBMS_PIPE verfügt über erweiterte Funktionen in Autonomous Database zur Unterstützung von Singleton Pipes.

Eine Singleton-Pipe in DBMS_PIPE:

• Bietet In-Memory-Caching von benutzerdefinierten Daten mit Singleton Pipe-Nachrichten.

• Unterstützt die Möglichkeit, eine benutzerdefinierte Nachricht mit bis zu 32.767 Byte zu cachen und abzurufen.

• Unterstützt die gemeinsame Verwendung einer gecachten Nachricht über mehrere Datenbanksessions hinweg mit gleichzeitigen Lesevorgängen. Dies bietet einen hohen Durchsatz und unterstützt gleichzeitige Lesevorgänge von Nachrichten über Datenbanksessions hinweg.

• Unterstützt schreibgeschützte und schreibgeschützte Datenbanken.

• Unterstützt verschiedene Methoden zur Cacheinvalidierung:

  • Explizite Cacheinvalidierung durch Benutzer gesteuert.
  • Cacheinvalidierung nach einem vom Benutzer angegebenen Zeitintervall (in Sekunden). Diese Invalidierungsmethode wird vom Nachrichtensender gesteuert, der den Parameter shelflife anstelle von Nachrichtenlesern verwendet. Dies vermeidet die häufigen Fallstricke aufgrund der falschen Verwendung von Cache durch Leser.

Über Standardrohre und Singleton Pipes

Mit dem DBMS_PIPE-Package können zwei oder mehr Datenbanksessions über In-Memory-Nachrichten kommunizieren. Die Pipe-Funktionalität umfasst mehrere Anwendungen wie externe Service-Schnittstelle, Debugging, unabhängige Transaktionen und Alerts.

Beschreibung der Abbildung database-pipe-messages-singleton-pipes.eps

Bei einer Singleton-Pipe kann es sich um einen der unterstützten DBMS_PIPE-Typen handeln:

• Implizite Pipe: Wird automatisch erstellt, wenn eine Nachricht mit einem unbekannten Pipe-Namen mit der Funktion DBMS_PIPE.SEND_MESSAGE gesendet wird.
• Explizite Pipe: Wird mit der Funktion DBMS_PIPE.CREATE_PIPE mit einem vom Benutzer angegebenen Pipe-Namen erstellt.
• Öffentliche Pipe: Jeder Benutzer mit der Berechtigung EXECUTE für das Package DBMS_PIPE kann darauf zugreifen.
• Private Pipe: Zugriff durch Sessions mit demselben Benutzer wie der Pipe-Ersteller möglich.

Singleton Pipes bieten die Möglichkeit, eine einzelne Nachricht im Speicher der Autonomous Database-Instanz zu cachen.

Im Folgenden wird der allgemeine Workflow für die Verwendung von Singleton-Pipes dargestellt.

Beschreibung der Abbildung singleton-pipe-workflow.eps

Mit dem Package DBMS_PIPE können Sie eine Singleton-Pipe-Nachricht automatisch mit einer benutzerdefinierten Cachefunktion auffüllen.

Standardmäßig führt eine nachfolgende DBMS_PIPE.RECEIVE_MESSAGE dazu, dass keine Nachricht empfangen wird, nachdem eine Nachricht mit einer expliziten oder impliziten Singleton Pipe invalidiert wurde. Um der Pipe eine neue Nachricht hinzuzufügen, muss die Nachricht durch Aufruf von DBMS_PIPE.SEND_MESSAGE explizit im Cache gespeichert werden. Um diesen Fall zu vermeiden, in dem beim Lesen aus einer Singleton Pipe keine Nachricht verfügbar ist, können Sie eine Cachefunktion definieren. Wenn eine Cache-Funktion definiert ist, wird die Cache-Funktion automatisch aufgerufen, wenn Sie in den folgenden Szenarios eine Meldung erhalten:

• Wenn die Singleton Pipe leer ist.
• Wenn die Nachricht in einer Singleton-Pipe aufgrund der verstrichenen shelflife-Zeit ungültig ist.

Um eine Cachefunktion zu verwenden, definieren Sie die Cachefunktion, und nehmen Sie den Parameter cache_func mit DBMS_PIPE.RECEIVE_MESSAGE auf. Eine benutzerdefinierte Cachefunktion bietet Folgendes:

• Die Cachefunktion kann beim Lesen einer Nachricht aus einer Singleton-Pipe mit DBMS_PIPE.RECEIVE_MESSAGE angegeben werden.
• Wenn keine Nachricht in der Singleton-Pipe vorhanden ist, ruft DBMS_PIPE.RECEIVE_MESSAGE die Cachefunktion auf.
• Wenn die shelflife-Zeit der Nachricht abgelaufen ist, füllt die Datenbank automatisch eine neue Nachricht in der Singleton-Pipe auf.

Die Verwendung einer Cache-Funktion vereinfacht die Arbeit mit Singleton Pipes. Sie müssen keine Fehlerfälle verarbeiten, um eine Nachricht von einer leeren Pipe zu empfangen. Darüber hinaus stellt eine Cachefunktion sicher, dass beim Lesen von Nachrichten aus einer Singleton-Pipe kein Cache-Miss vorhanden ist, was eine maximale Verwendung der gecachten Nachricht ermöglicht.

Wenn Sie eine Cache-Funktion definieren, muss der Funktionsname mit dem Eigentümerschema vollqualifiziert sein:

• OWNER.FUNCTION_NAME
• OWNER.PACKAGE.FUNCTION_NAME

Definieren Sie eine Cache-Funktion mit der folgenden Signatur:

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

Typische Vorgänge innerhalb einer Cache-Funktion sind:

• Erstellen Sie mit DBMS_PIPE.CREATE_PIPE eine Singleton Pipe für eine explizite Pipe.
• Erstellen Sie eine Nachricht, die in der Singleton-Pipe gecacht werden soll.
• Senden Sie die Nachricht an die in der Cachefunktion angegebene Pipe, und geben Sie optional eine shelflife für die implizite Nachricht an.

Um eine Cachefunktion zu verwenden, muss der aktuelle Sessionbenutzer, der DBMS_PIPE.RECEIVE_MESSAGE aufruft, über die erforderlichen Berechtigungen zum Ausführen der Cachefunktion verfügen.

Weitere Informationen zum Definieren einer Cachefunktion finden Sie unter Funktion RECEIVE_MESSAGE.

Beschreibt die Schritte zum Erstellen einer Singleton Pipe mit einem angegebenen Pipe-Namen (ein explizites Singleton Pipe).

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. Erstellen Sie eine explizite Singleton-Pipe namens PIPE_TEST mit dem Parameter shelflife, der auf 3600 (Sekunden) gesetzt ist.

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

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.

2. Prüfen Sie, ob die Singleton-Pipe erstellt wurde.

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

3. Packen und senden Sie eine Nachricht auf der 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

   Weitere Informationen finden Sie unter PACK_MESSAGE-Prozeduren und SEND_MESSAGE-Funktion.

4. Erhalten Sie eine Nachricht von einer Singleton-Pipe.

   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

   Die Funktion receive_message ist eine Helper-Funktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft.

5. Löschen Sie die Nachricht, und entfernen Sie die Pipe.

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

Beschreibt die Schritte zum Erstellen einer Singleton Pipe mit einem angegebenen Pipe-Namen und einer expliziten Singleton Pipe und zum Bereitstellen einer Cachefunktion. Mit einer Cache-Funktion können Sie die Nachricht automatisch in einer Singleton-Pipe auffüllen.

1. Erstellen Sie eine Cachefunktion, test_cache_message für eine Singleton-Pipe.

   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;
   /

   Hinweis
   
   Der aktuelle Sessionbenutzer, der DBMS_PIPE.RECEIVE_MESSAGE aufruft, muss über die erforderliche Berechtigung zum Ausführen der Cachefunktion verfügen.
2. Empfangen Sie mit einer Cache-Funktion, und bestätigen Sie, dass die Nachricht in der Pipe ausgefüllt wird. Die Pipe muss als private Pipe vorhanden sein, die in der Cachefunktion erstellt wurde.

   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
   

   Die Funktion receive_message ist eine Helper-Funktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft. Die Definition receive_message finden Sie unter Explizite Singleton-Pipe erstellen.

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.

3. Empfang ohne Cache-Funktion, um zu bestätigen, dass die Nachricht in der Pipe beibehalten wird.

   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

   Die Funktion receive_message ist eine Helper-Funktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft. Die Definition receive_message finden Sie unter Explizite Singleton-Pipe erstellen.

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.