Documentazione dell'infrastruttura Oracle Cloud

Memorizza nella cache i messaggi con Singleton Pipes

Singleton Pipe è un'aggiunta al pacchetto DBMS_PIPE che consente di inserire nella cache e recuperare un messaggio personalizzato e condividere il messaggio tra più sessioni di database con letture concorrenti.

Argomento padre: Cache dei messaggi con pipeline singleton e utilizzo di pipeline per la messaggistica persistente

Informazioni sulla memorizzazione nella cache dei messaggi con i tubi Singleton

Il pacchetto DBMS_PIPE ha esteso le funzionalità di Autonomous AI Database per supportare Singleton Pipes.

Un tubo Singleton in DBMS_PIPE:

  • Fornisce l'inserimento nella cache in memoria dei dati personalizzati utilizzando i messaggi Singleton Pipe.

  • Supporta la possibilità di inserire nella cache e recuperare un messaggio personalizzato fino a 32.767 byte.

  • Supporta la condivisione di un messaggio memorizzato nella cache in più sessioni di database con letture simultanee. Ciò fornisce throughput elevato e supporta letture simultanee dei messaggi in tutte le sessioni del database.

  • Supporta database di sola lettura e scrittura di lettura.

  • Supporta diversi metodi di annullamento convalida della cache:

    • Invalidamento esplicito della cache controllato dall'utente.
    • Annullamento convalida della cache dopo un intervallo di tempo specificato dall'utente (in secondi). Questo metodo di annullamento convalida è controllato dal mittente del messaggio, utilizzando il parametro shelflife, anziché dai lettori di messaggi. Questo evita le insidie comuni a causa dell'uso errato della cache da parte dei lettori.

Informazioni su tubi standard e tubi Singleton

Il pacchetto DBMS_PIPE consente a due o più sessioni di database di comunicare utilizzando messaggi in memoria. La funzionalità Pipe include diverse applicazioni quali l'interfaccia dei servizi esterni, il debug, le transazioni indipendenti e gli avvisi.

Segue la descrizione dell'immagine database-pipe-messages-singleton-pipes.eps
Descrizione dell'illustrazione database-pipe-messages-singleton-pipes.eps

Un tubo Singleton può essere uno qualsiasi dei tipi DBMS_PIPE supportati:

  • Tubo implicito: creato automaticamente quando un messaggio viene inviato con un nome pipe sconosciuto utilizzando la funzione DBMS_PIPE.SEND_MESSAGE.
  • Tubo esplicito: creato utilizzando la funzione DBMS_PIPE.CREATE_PIPE con un nome di pipe specificato dall'utente.
  • Public Pipe: accessibile da qualsiasi utente con autorizzazione EXECUTE sul pacchetto DBMS_PIPE
  • Tubo privato: accessibile da sessioni con lo stesso utente dell'autore della pipe.

Singleton Pipes offre la possibilità di inserire nella cache un singolo messaggio nella memoria dell'istanza di Autonomous AI Database.

Di seguito viene illustrato il flusso di lavoro generale per l'utilizzo di tubi singleton.

Segue la descrizione dell'immagine singleton-pipe-workflow.eps
Descrizione dell'illustrazione singleton-pipe-workflow.eps

Panoramica e caratteristiche di Singleton Pipe

  • Messaggi singleton

    • Un tubo Singleton può memorizzare un messaggio nella pipe, da qui il nome "singleton".
    • Il messaggio in un tubo Singleton può essere composto da più campi, fino a una dimensione totale del messaggio di 32.767 byte.
    • DBMS_PIPE supporta la possibilità di comprimere più attributi in un messaggio utilizzando la procedura DBMS_PIPE.PACK_MESSAGE.
    • Per una pipe Singleton pubblica, il messaggio può essere ricevuto da qualsiasi sessione di database con privilegio di esecuzione nel pacchetto DBMS_PIPE.
    • Per il tubo Singleton privato, il messaggio può essere ricevuto da sessioni con lo stesso utente del creatore del tubo Singleton.
  • Throughput messaggi elevato per le letture
    • Singleton Pipes memorizza nella cache il messaggio nella pipe finché non viene invalidato o rimosso. Le sessioni di database possono leggere contemporaneamente un messaggio da Singleton Pipe.
    • La ricezione di un messaggio da un tubo Singleton è un'operazione non bloccante.
  • Inserimento dei messaggi nella cache
    • Un messaggio viene inserito nella cache in una Singleton Pipe utilizzando DBMS_PIPE.SEND_MESSAGE.
    • Se nella tubazione Singleton è presente un messaggio inserito nella cache esistente, DBMS_PIPE.SEND_MESSAGE sovrascrive il messaggio precedente per mantenere un solo messaggio nella tubazione Singleton.
  • Annullamento convalida messaggio
    • Invalidazione esplicita: rimuove la pipe con la procedura DBMS_PIPE.PURGE o sovrascrivendo il messaggio utilizzando DBMS_PIPE.SEND_MESSAGE.
    • Annullamento automatico: un messaggio può essere invalidato automaticamente dopo il tempo shelflife specificato.
  • Nessuna rimozione dalla memoria del database
    • Singleton Pipes non viene rimosso dalla memoria di Oracle Database.
    • Una Singleton Pipe esplicita continua a risiedere nella memoria del database fino a quando non viene rimossa utilizzando DBMS_PIPE.REMOVE_PIPE o fino al riavvio del database.
    • Una pipe singleton implicita rimane nella memoria del database finché non viene inserito un messaggio nella cache nella pipe.

Singleton Pipe Operazioni

Operation Funzione o procedura DBMS_PIPE

Crea una pipe singleton esplicita

Funzione CREATE_PIPE

Inserisci un messaggio in Singleton Pipe

PACK_MESSAGE Procedure, funzione SEND_MESSAGE

Leggere un messaggio inserito nella cache da Singleton Pipe

Funzione RECEIVE_MESSAGE, UNPACK_MESSAGE Procedure

Eliminare un messaggio in Singleton Pipe

Procedura di rimozione

Rimuovere una pipe singleton esplicita

Funzione REMOVE_PIPE

Aggiornamento automatico del messaggio inserito nella cache con una funzione cache

Il pacchetto DBMS_PIPE consente di popolare automaticamente un messaggio Singleton Pipe utilizzando una funzione cache definita dall'utente.

Per impostazione predefinita, dopo che un messaggio viene invalidato con invalidazione esplicita o implicita di Singleton Pipe, un DBMS_PIPE.RECEIVE_MESSAGE successivo non restituisce alcun messaggio. Per aggiungere un nuovo messaggio alla pipe, il messaggio deve essere inserito nella cache in modo esplicito chiamando DBMS_PIPE.SEND_MESSAGE. Per evitare questo caso, in cui non è disponibile alcun messaggio quando si legge da una pipe Singleton, è possibile definire una funzione cache. Con una funzione cache definita, la funzione cache viene richiamata automaticamente quando si riceve un messaggio nei seguenti scenari:

  • Quando il tubo Singleton è vuoto.
  • Quando il messaggio in una Singleton Pipe non è valido a causa dell'ora trascorsa shelflife.

Per utilizzare una funzione cache, definire la funzione cache e includere il parametro cache_func con DBMS_PIPE.RECEIVE_MESSAGE. Una funzione cache definita dall'utente fornisce quanto riportato di seguito.

  • La funzione cache può essere specificata quando si legge un messaggio da una Singleton Pipe utilizzando DBMS_PIPE.RECEIVE_MESSAGE.
  • Quando non viene visualizzato alcun messaggio nella tubazione Singleton, DBMS_PIPE.RECEIVE_MESSAGE chiama la funzione cache.
  • Quando è trascorso il tempo shelflife del messaggio, il database inserisce automaticamente un nuovo messaggio nella tubazione Singleton.

L'utilizzo di una funzione cache semplifica l'utilizzo di Singleton Pipes. Non è necessario gestire i casi di errore per la ricezione di un messaggio da una pipe vuota. Inoltre, una funzione cache assicura che non ci sia cache-miss quando si leggono i messaggi da una Singleton Pipe, fornendo il massimo utilizzo del messaggio inserito nella cache.

Segue la descrizione dell'immagine automatic-cache-refresh-cache-function.eps
Descrizione dell'illustrazione automatic-cache-refresh-cache-function.eps

Quando si definisce una funzione cache, il nome della funzione deve essere completamente qualificato con lo schema proprietario:

  • OWNER.FUNCTION_NAME
  • OWNER.PACKAGE.FUNCTION_NAME

Definire una funzione cache con la firma seguente:

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

Le operazioni tipiche all'interno di una funzione cache sono le seguenti:

  • Creare una tubazione Singleton per una tubazione esplicita utilizzando DBMS_PIPE.CREATE_PIPE.
  • Creare un messaggio da inserire nella cache nella tubazione Singleton.
  • Inviare il messaggio alla pipe specificata nella funzione cache, specificando facoltativamente un shelflife per il messaggio implicito.

Per utilizzare una funzione cache, l'utente della sessione corrente che richiama DBMS_PIPE.RECEIVE_MESSAGE deve disporre dei privilegi necessari per eseguire la funzione cache.

Per ulteriori informazioni sulla definizione di una funzione cache, vedere RECEIVE_MESSAGE Function.

Crea una pipe singleton esplicita

Descrive i passaggi per creare una pipe Singleton con un nome di pipe specificato (una pipe Singleton esplicita).

In primo luogo, per questo esempio, creare la funzione di supporto receive_message per chiamare ripetutamente DBMS_PIPE.RECEIVE_MESSAGE. Ciò consente di testare la funzionalità del tubo singleton. 

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. Creare una pipe singleton esplicita denominata PIPE_TEST con il parametro shelflife impostato su 3600 (secondi).
    DECLARE
  l_status INTEGER;
BEGIN
  l_status := DBMS_PIPE.CREATE_PIPE(
                pipename => 'MY_PIPE1',
                private => TRUE,
                singleton => TRUE,
                shelflife => 3600);
END;
/

    Per ulteriori informazioni, vedere CREATE_PIPE Function.

  2. Verificare che la pipe singleton sia stata creata.
    SELECT name, singleton, type
     FROM v$db_pipes WHERE name= '&pipename' ORDER BY 1;

NAME                 SINGLETON  TYPE
-------------------- ---------- -------
PIPE_TEST            YES        PRIVATE
  3. Imballare e inviare un messaggio sul tubo singleton.
    
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

    Per ulteriori informazioni, vedere PACK_MESSAGE Procedures e SEND_MESSAGE Function.

  4. Ricevere un messaggio da una pipe 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 funzione receive_message è una funzione helper che chiama DBMS_PIPE.RECEIVE_MESSAGE.

  5. Rimuovere il messaggio e la pipe.
    EXEC DBMS_PIPE.PURGE('&pipename');
SELECT DBMS_PIPE.REMOVE_PIPE('&pipename') status FROM DUAL;

Creare una pipe singleton esplicita con una funzione cache

Descrive i passi per creare una pipe Singleton con un nome pipe specificato, una pipe Singleton esplicita e una funzione cache. Una funzione cache consente di popolare automaticamente il messaggio in una pipe singleton.

  1. Creare una funzione cache, test_cache_message per una pipe 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;
/
    Nota

    Per eseguire la funzione cache, l'utente della sessione corrente che richiama DBMS_PIPE.RECEIVE_MESSAGE deve disporre del privilegio richiesto.
  2. Ricevere con una funzione cache e confermare che il messaggio viene popolato nella pipe. La pipe deve esistere come pipe privata creata nella funzione 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 funzione receive_message è una funzione helper che chiama DBMS_PIPE.RECEIVE_MESSAGE. Vedere Create an Explicit Singleton Pipe per la definizione di receive_message.

    Per ulteriori informazioni, vedere CREATE_PIPE Function.

  3. Ricezione senza la funzione cache per confermare che il messaggio persiste nella pipe.
    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 funzione receive_message è una funzione helper che chiama DBMS_PIPE.RECEIVE_MESSAGE. Vedere Create an Explicit Singleton Pipe per la definizione di receive_message.

    Per ulteriori informazioni, vedere CREATE_PIPE Function.