Use of DBMS_AQ.LISTEN

Question

Hello, I have created a queue in which someone else constantly enqueues messages (about 20000 every 15 minutes) and I have added and registered some subscriber to dequeue the messages, with the packages dbms_aq.add_subscriber and dbms_aq.register.
Although it works fine, I don't like this solution because, if I stop and restart the queue (for administration reasons), the messages arrived when the queue is stopped aren't dequeued by any subscriber.
So I think to use DBMS_AQ.LISTEN, but I'm not sure which is the best way to use it. These are my issues: do I have to use DBMS_JOB to schedule it ? or better, which is the best way to launch and use the LISTEN procedure ?
Maybe this is not the best practice to use AQ, so every suggestion will be very appreciated.
Thanks,
Ennio

Answer 1

Hi Philippe,
no, I didn't find detailed information about this issue, nobody answered to my question about links or documentation, so actually I don't konw which are the best practises to use the LISTEN or the AQ.
But maybe I can help you. Some days ago I was playing with the AQ and I wanted to implement something like your issue.
Before explaining what I did, you need to know that:
- I suppose I need 10 subscribers
- the queue owner is ENNIO
- the name of the queue is EVENT_QUEUE
- the paylod of the queue is EVENT_TYPE
- the name of the subscribers are EVENT_CONSUMER_[1..10]
Then I suppose you know how to create the queue (remember to set the multiple_consumer parameter to TRUE) and that you know how to write the notify callback which dequeues the message.
First of all, I haven't any priority need: every message have the some priority than the others. For this reason, I use the priority option to determine which subscriber have to dequeue the message in this way:
1) create the subscribers with a LOOP:
begin
     FOR priority IN 1..10
     LOOP
          dbms_aqadm.add_subscriber (
               queue_name => 'ENNIO.EVENT_QUEUE',
               subscriber => sys.aq$_agent( 'EVENT_CONSUMER_' || priority, null, null )
               , rule => 'TAB.PRIORITY = ' || priority
     END LOOP;
end;
Look at the RULE parameter: this is the first key of the solution.
2) register the subscribers with a LOOP:
DECLARE
     reginfolist sys.aq$_reg_info_list;
BEGIN
     reginfolist := sys.aq$_reg_info_list(
               sys.aq$_reg_info('ENNIO.EVENT_QUEUE:EVENT_CONSUMER_1',
                    DBMS_AQ.NAMESPACE_AQ,
                    'plsql://ENNIO.notifyCB',
                    HEXTORAW('FF')
     FOR priority IN 2..10
     LOOP
          reginfolist.EXTEND;
          reginfolist(priority) :=
                    sys.aq$_reg_info('ENNIO.EVENT_QUEUE:EVENT_CONSUMER_' || priority,
                         DBMS_AQ.NAMESPACE_AQ,
                         'plsql://ENNIO.notifyCB',
                         HEXTORAW('FF')
     END LOOP;
     dbms_aq.register ( reginfolist, 10 );
END;
Now what you need is to enqueue the messages so that, in a RANDOM way, every message can be read just by one consumer. To do this I use the RANDOM PLSQL function and this is my enqueue procedure:
PROCEDURE enqueue (
          hostname in VARCHAR2,
          event in VARCHAR2,
          data in DATE
     AS
          enqueue_options dbms_aq.enqueue_options_t;
          message_properties dbms_aq.message_properties_t;
          message_handle RAW(16);
          message ENNIO.event_type;
     BEGIN
          message_properties.priority := DBMS_RANDOM.value(1,10);
          message := event_type(hostname, event, data);
          dbms_aq.enqueue(queue_name => 'ENNIO.EVENT_QUEUE',
               enqueue_options => enqueue_options,
               message_properties => message_properties,
               payload => message,
               msgid => message_handle);
          COMMIT;
          DBMS_OUTPUT.put_line('EVENTO ACCODATO: PRIORITY=' || message_properties.priority);
     END enqueue;
The DBMS_RANDOM function is the second key of the solution: in this way, every message has a random priority value, which is used to determine which will be the consumer that will dequeue the message.
As I told you I don't know well the AQ, the Oracle Agents and the procedure/functions to use in these contexts, so I don't know if there are better ways to do it.
Finally, I'm not sure the LISTEN function is really necessary, but I haven't found usefull documentation about it.
Finally (again:)), are you sure the subscriber is a good way ? I mean: if you stop the dequeue, but leaving the enqueue active, after you restart the queue, the subscribers will not read the messages arrived in the meanwhile.
I hope my example could help you and maybe that someone else could help us to understand more in depth the AQ world.
Bye,
Ennio