Nachrichten mit Singleton-Pipes cachen

Das Package DBMS_PIPE verfügt über erweiterte Funktionalität in Autonomous Database, um Singleton-Pipes zu unterstützen.

Eine Singleton Pipe in DBMS_PIPE:

• Stellt In-Memory-Caching von benutzerdefinierten Daten mithilfe von Singleton Pipe-Nachrichten bereit.

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

• Unterstützt die gemeinsame Verwendung einer gecachten Nachricht in mehreren Datenbanksessions mit gleichzeitigen Lesezugriffen. Dies bietet einen hohen Durchsatz und unterstützt gleichzeitiges Lesen von Nachrichten über Datenbanksessions hinweg.

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

• Unterstützt mehrere Cacheinvalidierungsmethoden:

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

Über Standardrohre und Singletonrohre

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

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

Eine Singleton Pipe kann einer der unterstützten DBMS_PIPE-Typen sein:

• 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 benutzerdefinierten Pipe-Namen erstellt.
• Öffentliche Pipe: Zugriff durch jeden Benutzer mit der Berechtigung EXECUTE für das Package DBMS_PIPE.
• Private Pipe: Zugriff durch Sessions mit demselben Benutzer wie der Pipe-Ersteller.

Mit Singleton Pipes können Sie eine einzelne Nachricht im Speicher der Autonomous Database-Instanz cachen.

Im Folgenden wird der allgemeine Arbeitsablauf 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 explizit gecacht werden, indem DBMS_PIPE.SEND_MESSAGE aufgerufen wird. Um diesen Fall zu vermeiden, wenn beim Lesen aus einer Singleton Pipe keine Nachricht verfügbar ist, können Sie eine Cache-Funktion definieren. Wenn eine Cache-Funktion definiert ist, wird die Cache-Funktion automatisch aufgerufen, wenn Sie eine Meldung in folgenden Szenarios 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 Cache-Funktion 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 Zeit für die Meldung shelflife 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. Für den Empfang einer Nachricht von einer leeren Pipe müssen Sie keine Fehlerfälle verarbeiten. Darüber hinaus stellt eine Cache-Funktion sicher, dass beim Lesen von Nachrichten aus einer Singleton-Pipe kein Cache-Fehlschlag vorhanden ist, wodurch die gecachte Nachricht maximal verwendet wird.

Wenn Sie eine Cache-Funktion definieren, muss der Funktionsname mit dem Eigentümerschema vollständig angegeben 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 eine Singleton-Pipe für eine explizite Pipe mit DBMS_PIPE.CREATE_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 verwenden zu können, 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 RECEIVE_MESSAGE-Funktion.

Beschreibt die Schritte zum Erstellen einer Singleton Pipe mit einem angegebenen Pipe-Namen (eine explizite 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 mit dem Namen PIPE_TEST, wobei der Parameter shelflife 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. Verpacken und senden Sie eine Nachricht in 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. Empfangen 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 Helperfunktion, 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, 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 Benutzer der aktuellen Session, der DBMS_PIPE.RECEIVE_MESSAGE aufruft, muss die erforderliche Berechtigung haben, um die Cachefunktion auszuführen.
2. Empfangen Sie mit einer Cache-Funktion, und bestätigen Sie, dass die Nachricht in der Pipe aufgefü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 Helperfunktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft. Informationen zur Definition receive_message finden Sie unter Explizite Singleton-Pipe erstellen.

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.

3. Empfangen 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 Helperfunktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft. Informationen zur Definition receive_message finden Sie unter Explizite Singleton-Pipe erstellen.

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.