public boolean hasPrev() 
	{
		if (currentPiped == null)
			return false;
		else if (currentPiped.hasPrev())
			return true;
		else if (previousPiped != null)
			return previousPiped.hasPrev();
		else if (!in.hasPrev())
			return false;
		else while (true)
		{
			// TODO - This is not the optimal way to do things,
			// we're relying on the fact that an application will
			// not be scanning back and forth frentically, but that it
			// will only occasionally need to look to a prev element.
			// The problem is that when we execute the pipe query, we need
			// to scan to the end of the result set so as to maintain linearity
			// in the overall "PipedResult".
			// A more intelligent buffering of previous result sets need
			// to be implemented if this proves to be a bottleneck (e.g.
			// have a static variable for buffer size and grow it as the need
			// arises). Or perhaps we should simply forbid bidirectionality in those
			// results simply because it cannot be implemented efficiently....

			pipe.setKey(in.prev());
			previousPiped = pipe.execute();
			if (previousPiped.hasNext())
			{
				do { previousPiped.next(); } while (previousPiped.hasNext());
				return true;
			}
			else
			{
				previousPiped.close();
				previousPiped = null;
				if (!in.hasPrev())
					return false;
			}
		}
	}