Quais são os casos reais de uso do enfileiramento avançado da Oracle?

Não estou tão familiarizado com o Oracle como estou com o Postgres. No entanto, vou lhe dizer onde vejo abordagens de enfileiramento como esta como ideais (como o autor de pg_message_queue ): permitir que transações de banco de dados tenham efeitos colaterais não transacionais com custo mínimo de complexidade. Um exemplo simples é "quando realizamos uma transação dizendo que enviamos uma peça, vamos enviar um e-mail notificando o cliente".

Você poderia fazer isso sem o Oracle AQ, mas o Oracle AQ provavelmente tornará isso mais simples. O fator chave é que isso permite que você enfileira a mensagem de forma que fique visível no commit e tenha a mensagem que será a base de um email assim que a transação do banco de dados for confirmada e não antes. Se você tentar enviar a mensagem de dentro da transação, receberá vários casos de falha desagradáveis:

1. Se a mensagem não for enviada, devemos abortar a transação?
2. Se a mensagem for enviada e a transação for revertida posteriormente, como cancelaremos o envio do e-mail? Não podemos.

Outro exemplo pode ser aplicativos fracamente acoplados, integrados em uma fila de mensagens. Cada aplicativo pode ser executado sem conhecimento do outro, mas quando as transações são confirmadas, as mensagens são enviadas para o outro. Se eles não puderem ser entregues imediatamente, não há problema. Vamos processá-los quando pudermos.

Portanto, o básico é que há muitos casos em que você deseja centralizar a lógica em torno do banco de dados, onde não pode realmente fazer tudo corretamente em uma única transação. Ser capaz de enviar mensagens para outros componentes no db commit é realmente útil.

E com certeza você poderia construir tudo sozinho sem AQ. Mas isso já foi construído para você.

Edit: Eu reli os documentos da Oracle aqui e eles são irremediavelmente confusos, então não o culpo por sua confusão aqui. Se eu já não estivesse um pouco familiarizado com os tipos de coisas sobre as quais eles estavam falando, não tenho certeza se seria capaz de segui-los. Agora tenho 100% de certeza de que minha resposta está no alvo.

Eu uso AQ para

• transações entre bancos de dados
• implementar regras de negócios que, de outra forma, precisariam ser implementadas usando gatilhos (ou seja, as ações devem ser executadas na mesma tabela que inicia a ação)

Usando uma fila, você pode fazer estas coisas:

• uma transação pode ocorrer na ordem que você deseja, mas não instantaneamente. por exemplo, inserir em um banco de dados, copiar o mesmo registro para outro banco de dados
• a segunda transação agora é independente da primeira, mas você ainda tem consistência. por exemplo, somente se a primeira inserção for bem-sucedida a segunda transação AQ ocorrerá e se a segunda transação ocorrer em outro banco de dados isso só acontecerá se o segundo banco de dados estiver pronto para receber

Aqui estão mais informações sobre como eu uso AQ entre bancos de dados. Eu não sou um especialista e peguei a maior parte do código da Internet. A documentação do Oracle é longa, mas realmente não me ajudou.

Primeiro crie a fila:

BEGIN
  SYS.DBMS_AQADM.CREATE_QUEUE_TABLE
  (
    QUEUE_TABLE           =>        'QT_NEW_CASE'
   ,QUEUE_PAYLOAD_TYPE    =>        'FILE_ACTION'
   ,COMPATIBLE            =>        '8.1'
   ,STORAGE_CLAUSE        =>        '
                                     TABLESPACE USERS
                                     PCTUSED    0
                                     PCTFREE    10
                                     INITRANS   1
                                     MAXTRANS   255
                                     STORAGE    (
                                                 INITIAL          64K
                                                 NEXT             1M
                                                 MINEXTENTS       1
                                                 MAXEXTENTS       UNLIMITED
                                                 PCTINCREASE      0
                                                 BUFFER_POOL      DEFAULT
                                                )'
   ,SORT_LIST             =>        'ENQ_TIME'
   ,MULTIPLE_CONSUMERS    =>         FALSE
   ,MESSAGE_GROUPING      =>         0
   ,SECURE                =>         FALSE
   );
End;

No banco de dados de origem:

CREATE OR REPLACE TYPE FILE_ACTION                                                                                                                                                       AS OBJECT
(    ACTION VARCHAR2(20),
     CASE_ID NUMBER(10),
     OTHER VARCHAR2(20)
);

A ação é reconhecidamente grosseira, mas versátil. Os requisitos eram afunilar as alterações de várias tabelas para outro banco de dados onde era necessário processamento adicional sem tocar no código do aplicativo. Uma chamada típica é para um pacote de um gatilho, outro procedimento ou trabalho.

queue_util.add_file ('CLOSE', v_case_id,:NEW.ID);

Dentro do pacote

   PROCEDURE add_file_to_queue (action_in      IN VARCHAR2,
                                d_case_id_in   IN NUMBER,
                                d_other_in     IN VARCHAR2:= NULL)
   IS
      /******************************************************************************
      PURPOSE: when there is a change to a file (create, closed or reopen)  add the change to the queue of changes 
     ******************************************************************************/
      queue_options        SYS.DBMS_AQ.enqueue_options_t;
      message_properties   SYS.DBMS_AQ.message_properties_t;
      message_id           RAW (16);
      my_message           file_action;
      err_text             VARCHAR2 (2000);
      PRAGMA AUTONOMOUS_TRANSACTION;
   BEGIN
      my_message := file_action (action_in, d_case_id_in, d_other_in);
      DBMS_AQ.enqueue (queue_name           => 'NEW_CASE_QUEUE',
                       enqueue_options      => queue_options,
                       message_properties   => message_properties,
                       payload              => my_message,
                       msgid                => message_id);

      IF g_debugging
      THEN
        ;
      --insert debugging info if g_debugging is true
      END IF;

      COMMIT;
   EXCEPTION
      WHEN NO_DATA_FOUND
      THEN
         err_text := SQLERRM;
         --logging error to another table

      WHEN OTHERS
      THEN
         err_text := SQLERRM;
         --more logging
   END add_file_to_queue;

--e tirando mensagens da fila

   PROCEDURE send_from queue (case_id_in IN NUMBER := NULL)
   IS
      /******************************************************************************
      PURPOSE:get the list of file changes and send them out
      *****************************************************************************/
      queue_options                DBMS_AQ.dequeue_options_t;
      message_properties           DBMS_AQ.message_properties_t;
      message_id                   file_action;
      v_file                       VARCHAR2 (20);
      v_case_id                    NUMBER (10);
      v_filename                   VARCHAR2 (500);
      v_action                     VARCHAR2 (20);
      v_other                      VARCHAR2 (20);
      v_err_id                     INTEGER;
      bad_data_ex EXCEPTION;
      v_err_text                   VARCHAR2 (50);

      TYPE cases_cur IS REF CURSOR;

      new_cases                    cases_cur;
   BEGIN
      IF case_id_in IS NULL
      THEN
         OPEN new_cases FOR
              SELECT   qt.msgid
                FROM   cqt_new_case qt
            ORDER BY   qt.enq_time;
      ELSE
         OPEN new_cases FOR
              SELECT   qt.msgid
                FROM   qt_new_case qt
               WHERE   qt.user_data.case_id = case_id_in
            ORDER BY   qt.enq_time;
      END IF;

      --should have added a check here to make sure
      --the other database is up and running
      LOOP
         BEGIN
            FETCH new_cases INTO   message_id;

            --reinitialize values to null
            v_case_id := NULL;
            v_filename := NULL;
            v_file := NULL;
            v_action := NULL;
            v_other := NULL;
            --to try and clear all locks
            COMMIT;
            EXIT WHEN new_cases%NOTFOUND;

            IF case_id_in IS NOT NULL
            THEN
               queue_options.deq_condition :=
                  'tab.user_data.case_id = ' || case_id_in;
            END IF;

            DBMS_AQ.dequeue (queue_name           => 'NEW_CASE_QUEUE',
                             dequeue_options      => queue_options,
                             message_properties   => message_properties,
                             payload              => my_message,
                             msgid                => message_id);
            v_case_id := my_message.case_id;
            v_action := my_message.action;
            v_other := my_message.other;

            IF v_case_id IS NOT NULL AND v_case_id > 0
            THEN
               IF g_debugging
               THEN
                 ;
               --insert your debugging information
               END IF;
            --continues on with lengthy data transforms
            --for actions like NEW, CLOSE, REOPEN
END SEND_FROM_QUEUE;

Eu certamente escreveria isso de forma diferente hoje, mas funciona... O principal problema com o AQ para mim é que eu nunca recebi mensagens de fila para fila entre bancos de dados diferentes. Isso foi descrito como um valor primário para ele. No entanto, ainda gosto de ter a certeza de que a transação inicial pode ser concluída sem levar em consideração o estado do banco de dados de destino. Se a mensagem não for inserida no banco de dados de destino, um erro será registrado e um e-mail será enviado notificando o desenvolvedor.

Na vida real, o AQ pode ser usado para enviar notificações aos clientes quando uma ação específica é executada no banco de dados.

Considere um exemplo em que um usuário solicitou a compra de um item. Assim que o pagamento for recebido, um pedido será criado preenchendo a fila com os detalhes. Essa fila terá assinantes para o dono da loja e os aplicativos de mensagens de pagamento.

Assim, o assinante 1, ou seja, o dono da loja (qualquer notificação a ser enviada ao dono da loja) escolherá a mensagem sobre o item a ser enviado. e outro assinante preparará a notificação sobre o item adquirido, portanto, neste caso, uma vez que a mensagem seja processada pelo assinante, o pedido é marcado como concluído e a mensagem da fila é removida.

Se durante o processamento do pedido ocorrer algum erro, uma entrada será marcada na fila de exceção e as mensagens da fila de exceção poderão ser processadas posteriormente.

Você pode usar o Oracle AQ para vários exemplos da vida real, como usamos -

1. Ordem de fluxo de pedidos - Temos vários pedidos chegando, que precisam ser processados ​​em um determinado pedido para que o cliente coloque a mensagem de diferentes lugares em momentos diferentes, então apenas enfileiramos a mensagem e obtemos o pedido correto durante o desenfileiramento.
2. Usamos o Oracle AQ para notificação do fluxo de trabalho completo, ou seja, algum cliente que iniciou/enviou um procedimento para ser executado com sucesso o mesmo é executado pelo agendador, portanto, uma vez que este procedimento termine o processamento, enfileiramos uma mensagem que notifica o cliente que iniciou o procedimento (usando oracle aq pl/sql notificações).
3. O melhor uso é replicar dados de um banco de dados para outro, você acabou de definir o assinante remoto, então o AQ transferirá os dados de uma fila para outra fila na mesma ordem internamente, isso é chamado de propagação, que também está sendo usado nos fluxos oracle .

Depende do requisito dos aplicativos da Web e do propósito de usar o Advanced Queueing.

Acho que existem alternativas como comparar o timestamp que inicia a consulta e, portanto, verificar a prioridade da consulta de transação a ser executada primeiro.