Prefetch syntax
This is to differentiate pre-fetched "static" results from the descriptor that exposes related objects as a `SelectQuery`.

I do not plan on changing this, but you can modify your code:

``` python
def format_messages(user):
    messages = getattr(user, 'messages_prefetch', user.messages)
    return [message.data for message in messages]
```

Hey Charles,

I've been writing a few methods with prefetch and find it incredibly useful but I wondered why the syntax is different to the regular, non-prefetch solution and whether it's possible to merge the two approaches.

For example:

``` python
class User(Model):
    name = CharField()

class Message(Model):
    user = ForeignKeyField(User)
    data = TextField()

# Create models and populate data ...
```

Existing (contrived to simplify) prefetch selection solution.

``` python
users = User.select()
messages = Message.select()

data = []
for user in prefetch(users, messages):
    data.extend(format_messages(user))
else:
    print data

def format_messages(user):
    return [message.data for message in user.messages_prefetch]
```

This works great but my dilemma is that now I want to do this:

``` python
user = User.get(User.id == user_id)
data = format_messages(user)
```

And this results in an `AttributeError` on `messages_prefetch` :(

The question I have is how come the prefetch and non-prefetch syntax differ? Surely it's lazy evaluation so either the data is there or it needs to be fulfilled. Is this just an oversight or am I missing something more fundamental? I'm guessing the latter.

What I'm envisaging is that prefetch just uses the regular syntax.

``` python
def format_messages(user):
    return [message.data for message in user.messages]
```

Sorry for the annoying question, but it's been bugging me a little while. We use this pattern a fair amount for RESTful GET calls in both single/multiple and I'd like to be able to reuse the same formatting functions.
