Nachrichten mit Singleton-Pipes cachen

Singleton Pipe ist eine Ergänzung zum Package DBMS_PIPE, mit der Sie eine benutzerdefinierte Nachricht cachen und abrufen und die Nachricht über mehrere Datenbanksessions hinweg mit gleichzeitigen Lesevorgängen gemeinsam verwenden können.

Informationen zum Cachen von Nachrichten mit Singleton-Rohren

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 von bis zu 32.767 Byte zu cachen und abzurufen.

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

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

• Unterstützt mehrere Methoden zur Cacheinvalidierung:

  • Vom Benutzer gesteuerte explizite Cacheinvalidierung.
  • Cacheinvalidierung nach einem vom Benutzer angegebenen Zeitintervall (in Sekunden). Diese Invalidierungsmethode wird vom Absender der Nachricht mit dem Parameter shelflife und nicht von den Nachrichtenlesern gesteuert. Dies vermeidet die häufigen Fallstricke aufgrund der falschen Verwendung des Cache durch Leser.

Über Standardrohre und Singletonrohre

Mit dem Package DBMS_PIPE können zwei oder mehr Datenbanksessions mit In-Memory-Nachrichten kommunizieren. Die Pipe-Funktionalität umfasst mehrere Anwendungen wie externe Serviceschnittstelle, Debugging, unabhängige Transaktionen und Alerts. Weitere Informationen finden Sie unter DBMS_PIPE in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 23ai PL/SQL-Packages und Typenreferenz.

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 für alle 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 Workflow für die Verwendung von Singleton-Pipes gezeigt.

Beschreibung der Abbildung singleton-pipe-workflow.eps

Singleton Pipe Übersicht und Features

• Singleton-Nachrichten

  • Eine Singleton Pipe kann eine Nachricht in der Pipe cachen, daher der Name "singleton".
  • Die Nachricht in einer Singleton Pipe kann aus mehreren Feldern bestehen, bis zu einer Gesamtnachrichtengröße von 32.767 Byte.
  • DBMS_PIPE unterstützt die Möglichkeit, mehrere Attribute in einer Nachricht mit der Prozedur DBMS_PIPE.PACK_MESSAGE zu packen.
  • Bei einer öffentlichen Singleton Pipe kann die Nachricht von jeder Datenbanksession mit Ausführungsberechtigung für das Package DBMS_PIPE empfangen werden.
  • Bei Private Singleton Pipe kann die Nachricht von Sessions mit demselben Benutzer wie der Ersteller der Singleton Pipe empfangen werden.
• Hoher Nachrichtendurchsatz für Lesevorgänge
  • Singleton Pipes cachen die Nachricht in der Pipe, bis sie invalidiert oder gelöscht wird. Datenbanksessions können gleichzeitig eine Nachricht aus der Singleton Pipe lesen.
  • Der Empfang einer Nachricht von einer Singleton Pipe ist ein nicht blockierender Vorgang.
• Nachrichten-Caching
  • Eine Nachricht wird in einer Singleton-Pipe mit DBMS_PIPE.SEND_MESSAGE gecacht.
  • Wenn in der Singleton-Pipe eine gecachte Nachricht vorhanden ist, überschreibt DBMS_PIPE.SEND_MESSAGE die vorherige Nachricht, um nur eine Nachricht in der Singleton-Pipe beizubehalten.
• Invalidierung der Nachricht
  • Explizite Invalidierung: Löscht die Pipe mit der Prozedur DBMS_PIPE.PURGE oder durch Überschreiben der Nachricht mit DBMS_PIPE.SEND_MESSAGE.
  • Automatische Invalidierung: Eine Nachricht kann automatisch invalidiert werden, nachdem die angegebene shelflife-Zeit abgelaufen ist.
• Keine Entfernung aus Datenbankspeicher
  • Singleton Pipes werden nicht aus dem Oracle Database-Speicher entfernt.
  • Eine explizite Singleton Pipe befindet sich weiterhin im Datenbankspeicher, bis sie mit DBMS_PIPE.REMOVE_PIPE entfernt wird oder bis die Datenbank neu gestartet wird.
  • Eine implizite Singleton Pipe bleibt im Datenbankspeicher, bis eine gecachte Nachricht in der Pipe vorhanden ist.

Singleton-Rohrvorgänge

Vorgang	DBMS_PIPE-Funktion oder -Prozedur
Explizite Singleton-Pipe erstellen	Funktion CREATE_PIPE
Nachricht in Singleton Pipe cachen	PACK_MESSAGE-Prozeduren in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 23ai PL/SQL-Packages und Typenreferenz Funktion SEND_MESSAGE
Gecachte Nachricht von Singleton Pipe lesen	RECIEVE_MESSAGE-Funktion, UNPACK_MESSAGE-Prozeduren in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder PL/SQL-Packages und Typenreferenz für Oracle Database 23ai
Nachricht in Singleton Pipe löschen	PURGE-Prozedur in Oracle Database 19c PL/SQL-Pakete und Typenreferenz oder Oracle Database 23ai PL/SQL-Pakete und Typenreferenz
Explizite Singleton Pipe entfernen	REMOVE_PIPE-Funktion in Oracle Database 19c PL/SQL-Paketen und Typenreferenz oder Oracle Database 23ai PL/SQL-Pakete und Typenreferenz

Automatische Aktualisierung von gecachten Nachrichten mit einer Cache-Funktion

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

Wenn eine Nachricht mit expliziter oder impliziter Invalidierung von Singleton Pipe invalidiert wurde, führt ein nachfolgender DBMS_PIPE.RECEIVE_MESSAGE standardmäßig dazu, dass keine Nachricht empfangen wird. 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 Cachefunktion definieren. Wenn eine Cache-Funktion definiert ist, wird die Cache-Funktion automatisch aufgerufen, wenn Sie eine Nachricht in den 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 shelflife-Zeit der Nachricht verstrichen 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-Fehlschlag vorliegt, wodurch die gecachte Nachricht maximal verwendet wird.

Beschreibung der Abbildung automatisch-cache-refresh-cache-function.eps

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 Cachefunktion sind:

• Erstellen Sie mit DBMS_PIPE.CREATE_PIPE eine Singleton-Pipe für eine explizite Pipe.
• Erstellen Sie eine Nachricht für den Cache in der Singleton Pipe.
• 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 RECIEVE_MESSAGE-Funktion.

Explizite Singleton-Pipe erstellen

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

Zuerst erstellen Sie in diesem Beispiel die Helper-Funktion receive_message, um DBMS_PIPE.RECEIVE_MESSAGE wiederholt aufzurufen. So können Sie die Singleton-Pipe-Funktionalität testen.

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 Procedures in der Oracle Database 19c PL/SQL Packages and Types Reference oder in der Oracle Database 23ai PL/SQL Packages and Types Reference und in der SEND_MESSAGE Function.

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;

Explizite Singleton-Pipe mit einer Cachefunktion erstellen

Beschreibt die Schritte zum Erstellen einer Singleton Pipe mit einem angegebenen Pipe-Namen, einer expliziten Singleton Pipe und zum Bereitstellen einer Cache-Funktion. 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 erforderlichen Berechtigungen verfügen, um die Cachefunktion auszuführen.
2. Empfangen Sie eine Cachefunktion, 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 Helper-Funktion, die DBMS_PIPE.RECEIVE_MESSAGE aufruft. Informationen zur Definition von 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. Informationen zur Definition von receive_message finden Sie unter Explizite Singleton-Pipe erstellen.

   Weitere Informationen finden Sie unter Funktion CREATE_PIPE.

---

Titel und Copyright-Informationen

Copyright ©2024,2024,

Oracle und/oder verbundene Unternehmen.