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 di 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 inserito nella cache in più sessioni di database con letture simultanee. Ciò garantisce un throughput elevato e supporta le letture simultanee dei messaggi tra le sessioni del database.

• Supporta database di sola lettura e lettura e scrittura.

• Supporta diversi metodi di annullamento convalida della cache:

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

Informazioni sui tubi standard e sui tubi Singleton

Il pacchetto DBMS_PIPE consente la comunicazione tra due o più sessioni del database mediante messaggi in memoria. La funzionalità Pipe dispone di diverse applicazioni come l'interfaccia del servizio esterno, il debug, le transazioni indipendenti e gli avvisi.

Descrizione dell'immagine database-pipe-messages-singleton-pipes.eps

Una pipe Singleton può essere uno dei tipi DBMS_PIPE supportati:

• Pipe implicita: viene creato automaticamente quando viene inviato un messaggio con un nome pipe sconosciuto utilizzando la funzione DBMS_PIPE.SEND_MESSAGE.
• Pipe esplicita: viene creato utilizzando la funzione DBMS_PIPE.CREATE_PIPE con un nome pipe specificato dall'utente.
• Public Pipe: accessibile da qualsiasi utente con autorizzazione EXECUTE sul pacchetto DBMS_PIPE.
• Pipe privata: è accessibile dalle sessioni con lo stesso utente dell'autore della pipe.

Singleton Pipes consente 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 dei tubi singleton.

Descrizione dell'immagine singleton-pipe-workflow.eps

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

Per impostazione predefinita, dopo l'annullamento della convalida di un messaggio con Singleton Pipe esplicita o implicita, un DBMS_PIPE.RECEIVE_MESSAGE successivo non riceverà 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 la Singleton Pipe è vuota.
• Quando il messaggio in una pipe Singleton non è valido a causa del tempo shelflife trascorso.

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 segue:

• La funzione cache può essere specificata quando si legge un messaggio da una pipe Singleton utilizzando DBMS_PIPE.RECEIVE_MESSAGE.
• Quando non viene visualizzato alcun messaggio nella pipe Singleton, DBMS_PIPE.RECEIVE_MESSAGE chiama la funzione cache.
• Quando il tempo del messaggio shelflife è trascorso, il database inserisce automaticamente un nuovo messaggio nella barra verticale 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 uso 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 seguente firma:

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

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

• Creare una pipe Singleton per una pipe esplicita utilizzando DBMS_PIPE.CREATE_PIPE.
• Creare un messaggio da inserire nella cache nella Singleton Pipe.
• Inviare il messaggio alla pipe specificata nella funzione cache, specificando facoltativamente un valore 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 Funzione.

Descrive i passi per creare una pipe Singleton con un nome 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 sulla pipe 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 Procedure e Funzione SEND_MESSAGE.

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 di supporto che chiama DBMS_PIPE.RECEIVE_MESSAGE.

5. Rimuovere il messaggio e rimuovere 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 fornire una funzione di cache. Una funzione cache consente di inserire 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
   
   L'utente della sessione corrente che richiama DBMS_PIPE.RECEIVE_MESSAGE deve disporre dei privilegi necessari per eseguire la funzione cache.
2. Ricevi con una funzione cache e conferma che il messaggio viene inserito 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 di supporto che chiama DBMS_PIPE.RECEIVE_MESSAGE. Per la definizione receive_message, vedere Creare una pipe Singleton esplicita.

   Per ulteriori informazioni, vedere CREATE_PIPE Function.

3. Ricevi 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 di supporto che chiama DBMS_PIPE.RECEIVE_MESSAGE. Per la definizione receive_message, vedere Creare una pipe Singleton esplicita.

   Per ulteriori informazioni, vedere CREATE_PIPE Function.