code: public boolean relative(int row) throws PersistenceBrokerException
      {
          if (row == 0)
          {
              return true;
          }
  
          boolean movedToRelative = false;
          boolean retval = false;
          setNextIterator();
  
          if (row > 0)
          {
              // special case checking for the iterator we're currently in
              // (since it isn't positioned on the boundary potentially)
              if (row > (m_activeIterator.size() - m_currentCursorPosition))
              {
                  // the relative position lies over the border of the
                  // current iterator.
  
                  // starting position counter should be set to whatever we have left in
                  // active iterator.
                  int positionCounter = m_activeIterator.size() - m_currentCursorPosition;
                  for (int i = m_activeIteratorIndex + 1; ((i < m_rsIterators.size()) && !movedToRelative); i++)
                  {
                      m_activeIteratorIndex = i;
                      m_currentCursorPosition = 0;
                      m_activeIterator = (OJBIterator) m_rsIterators.get(m_activeIteratorIndex);
                      if (!((row - positionCounter) > m_activeIterator.size()))
                      {
                          // the relative position requested is within this iterator.
                          m_currentCursorPosition = row - positionCounter;
                          retval = m_activeIterator.relative(m_currentCursorPosition);
                          movedToRelative = true;
                      }
                  }
              }
              else
              {
                  // the relative position lays within the current iterator.
                  retval = m_activeIterator.relative(row);
                  movedToRelative = true;
              }
          }
  
          return retval;
      }
docs: Moves the cursor a relative number of rows.
  Movement can go in forward (positive) or reverse (negative).
  
  Calling relative does not "wrap" meaning if you move before first or
  after last you get positioned at the first or last row.
  
  Calling relative(0) does not change the cursor position.
  
  Note: Calling the method relative(1) is different from calling
  the method next() because is makes sense to call next() when
  there is no current row, for example, when the cursor is
  positioned before the first row or after the last row of
  the result set.