One of the reasons I was asking this is because I have been
experimenting with the JMS Message Queue implementation of JBoss. I
have found out that that implementation is not good at all, and
unusable with high message loads. To be fair however JBoss people
acknowledge that (at least some of them) and they are rewriting it for
4.0

One of the things that the JBoss messaging subsystem does  when
booting up, is the following query to the database (when using a
PersitanceManager that stores messages in the database):

"SELECT MESSAGEID, MESSAGEBLOB FROM JMS_MESSAGES WHERE DESTINATION=?"

In other words it does a query for all messages on a single queue. If
that queue is big, there will obviously be memory problems like I was
pointing out in my message. The code that does the queue restoring in
JBoss in case you're interested is in the
org.jboss.mq.pm.jdbc2.PersistenceManager and the function is
restoreQueue:

  /////////////////////////////////////////////////////////////////////////////////
  //
  // Message Recovery
  //
  /////////////////////////////////////////////////////////////////////////////////
  synchronized public void restoreQueue(JMSDestination jmsDest,
SpyDestination dest) throws javax.jms.JMSException
  {
     if (jmsDest == null)
        throw new IllegalArgumentException("Must supply non null
JMSDestination to restoreQueue");
     if (dest == null)
        throw new IllegalArgumentException("Must supply non null
SpyDestination to restoreQueue");

     TransactionManagerStrategy tms = new
TransactionManagerStrategy();
     tms.startTX();
     Connection c = null;
     PreparedStatement stmt = null;
     ResultSet rs = null;
     boolean threadWasInterrupted =
Thread.currentThread().interrupted();
     try
     {

        c = this.getConnection();
        stmt = c.prepareStatement(SELECT_MESSAGES_IN_DEST);
        stmt.setString(1, dest.toString());

        rs = stmt.executeQuery();
        int counter=0;
        while (rs.next())
        {
           SpyMessage message = extractMessage(rs);
           // The durable subscription is not serialized
           if (dest instanceof SpyTopic)
              message.header.durableSubscriberID =
((SpyTopic)dest).getDurableSubscriptionID();
           jmsDest.restoreMessage(message);
           counter++;
        }
       
        log.debug("Restored "+counter+" message(s) to: "+dest);
     }
     catch (IOException e)
     {
        tms.setRollbackOnly();
        throw new SpyJMSException("Could not restore messages to
destination : " + dest.toString(), e);
     }
     catch (SQLException e)
     {
        tms.setRollbackOnly();
        throw new SpyJMSException("Could not restore messages to
destination : " + dest.toString(), e);
     }
     finally
     {
        try
        {
           rs.close();
        }
        catch (Throwable ignore)
        {
        }
        try
        {
           stmt.close();
        }
        catch (Throwable ignore)
        {
        }
        try
        {
           c.close();
        }
        catch (Throwable ignore)
        {
        }
        tms.endTX();

        // Restore the interrupted state of the thread
        if( threadWasInterrupted )
           Thread.currentThread().interrupt();
     }

  }