Memorizza nella cache i messaggi con Singleton Pipes

Il package DBMS_PIPE dispone di funzionalità estese su Autonomous 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.

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

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

Descrizione dell'illustrazione singleton-pipe-workflow.eps

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.

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.

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

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;

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.