Nachrichten mit Singleton-Pipes cachen

Singleton Pipe ist eine Ergänzung des Packages DBMS_PIPE, mit dem Sie eine benutzerdefinierte Nachricht cachen und abrufen und die Nachricht für mehrere Datenbanksessions mit gleichzeitigen Lesezugriffen freigeben können.

Nachrichten mit Singleton-Pipen cachen

Das Package DBMS_PIPE verfügt über erweiterte Funktionalität in der autonomen KI-Datenbank zur Unterstützung von Singleton Pipes.

Eine Singleton Pipe in DBMS_PIPE:

Über Standardrohre und Singletonrohre

Mit dem DBMS_PIPE-Package können zwei oder mehr Datenbanksessions mit In-Memory-Meldungen kommunizieren. Die Pipe-Funktionalität verfügt über 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 and Types Reference oder Oracle Database 26ai PL/SQL Packages and Types Reference.

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

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

Singleton Pipes bieten die Möglichkeit, eine einzelne Nachricht im Speicher der autonomen KI-Datenbankinstanz zu cachen.

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

Beschreibung der Abbildung singleton-pipe-workflow.png

Singleton Pipe – Übersicht und Features

Singleton Pipe-Vorgänge

Vorgang DBMS_PIPE - Funktion oder Ablauf
Explizite Singleton Pipe erstellen CREATE_PIPE-Funktion
Nachricht in Singleton Pipe cachen

PACK_MESSAGE-Prozeduren in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 26ai PL/SQL-Packages und Typenreferenz

SEND_MESSAGE-Funktion
Gespeicherte Nachricht von Singleton Pipe lesen RECEIVE_MESSAGE-Funktion, UNPACK_MESSAGE-Prozeduren in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 26ai PL/SQL-Packages und Typenreferenz
Nachricht in Singleton-Pipe löschen PURGE-Prozedur in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 26ai PL/SQL-Packages und Typenreferenz
Explizite Singleton Pipe entfernen REMOVE_PIPE-Funktion in Oracle Database 19c PL/SQL-Packages und Typenreferenz oder Oracle Database 26ai PL/SQL-Packages und Typenreferenz

Automatische Aktualisierung zwischengespeicherter Nachrichten mit einer Cachefunktion

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:

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

Beschreibung von automatic-cache-refresh-cache-function.eps folgt

Beschreibung der Abbildung automatic-cache-refresh-cache-function.png

Wenn Sie eine Cache-Funktion definieren, muss der Funktionsname mit dem Eigentümerschema vollständig angegeben sein:

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:

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 (eine explizite Singleton Pipe).

Erstellen Sie zunächst in diesem Beispiel die Helper-Funktion receive_message, um DBMS_PIPE.RECEIVE_MESSAGE wiederholt aufzurufen. Auf diese Weise 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 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. Packen 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 in der Referenz zu Oracle Database 19c PL/SQL-Packages und -Typen oder unter Oracle Database 26ai PL/SQL Packages and Types Reference und SEND_MESSAGE Function.

  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;

Explizite Singleton Pipe mit einer Cache-Funktion erstellen

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 aktuelle Sessionbenutzer, 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.

Verwandte Inhalte