Memory Caching Question
So peewee select queries are not executed until iterated over (although explicitly calling `execute()` on a Select query *will* execute it, returning a cursor wrapper, but that's kinda beside the point).

However, this code *only* issues and executes a single query:

```python
query = Tweet.select().limit(50)

# Query is executed here.
for tweet in query:
    ...

# These iterations and other operations do not re-execute the query.
for tweet in query:
    ...

tweets = list(query)

first_tweet = query[0]
...
```

During the first iteration the resulting rows are cached, in memory, so that subsequent iterations and even indexing will not hit the database again. This is what is meant by caching in Peewee -- rows are cached so that the query result can be operated on more than just a single-shot iteration.

If, however, you are processing a ton of rows iteratively and all you need is a single iteration, you can save memory by using `.iterator()`. When using `.iterator()`, attempting to iterate over the query a second time will yield no rows/no data.

I'm not sure why you are coercing it to a list - that should be unnecessary in any case, since simply iterating and re-iterating the query will not yield additional executions. I'm just coercing to a list for demonstration purposes. In terms of forcing the select to execute, calling `list(Tweet.select())` is the same as `for tweet in Tweet.select():`.

If I need to load all the rows into memory anyways to accomplish some task, is there any benefit to calling `iterator()`? I'm pretty sure the answer is no, right?

For example, there is no benefit to calling `iterator()` in this this REST API example:

```
@app.get('/tweets/')
def get_tweets():
    tweets = Tweet.select().iterator()
    return TweetSchema.dump(tweets, many=True)

```

Is that right?
 No there's no reason to worry about it unless, like the docs say, you intend to iterate over so many rows that memory usage would become an issue.
Not a bug, just a question.

In the documentation it states the following:

> Subsequent iterations of the same query will not hit the database as the results are cached. To disable this behavior (to reduce memory usage), call Select.iterator() when iterating.

I'm not clear in what circumstances I would want to call `iterator()` to reduce memory consumption.

In my web app I am commonly doing something like the following:

```
@app.get('/tweets/')
def get_tweets():
    tweets = list(Tweet.select())  # as opposed to list(Tweet.select().iterator())
    return TweetSchema.dump(tweets, many=True)
```

Am I using twice as much memory as required if I do `tweets = list(Tweet.select())` compared to `tweets = list(Tweet.select().iterator())` ?

I don't think so, because of the following shows that it is by reference, not by value:

```
    sel = Tweet.select()
    tweets = list(sel)

     assert sel[0] is tweets[0]
     assert id(sel[0]) == id(tweets[0])
```

