Next result cached in Select.iterator()
If you read the peewee code for `CursorWrapper` you will see that peewee is not eagerly fetching anything. The behavior you are seeing is a side-effect of the interaction between pysqlite (the stdlib sqlite driver) and how sqlite operates. You can see that [here](https://github.com/coleifer/pysqlite3/blob/master/src/cursor.c#L710-L772) pysqlite fetches the next row.

I'd suggest that you're doing something weird and should probably a) read all rows first, or b) not modify them while iterating over the cursor. Ordinarily this isn't a problem if you are using separate connections to do the reading/modifying because this is either completely prevented or, if using wal-mode, the read operates on a snapshot. It only can occur if you're modifying the table and iterating at the same time, which seems problematic for what I hope are obvious reasons. Thank you for the quick response! I figured it was something wrong with my understanding of this.

Thankfully I was not building actual code, just experimenting with the details of how the .iterator() worked. I was essentially wanting to see what would happen using different processes, and I didn't know about the other ways this is prevented. Thank you, and great work on this package!
I ran into an unexpected behavior that didn't seem to match what _I assume_ the documentation is saying. 

In the documentation under [Iterating over large result-sets](http://docs.peewee-orm.com/en/latest/peewee/querying.html#iterating-over-large-result-sets) it states:

> To reduce the amount of memory used by peewee when iterating over a query, use the `iterator()` method. This method allows you to iterate without caching each model returned, using much less memory when iterating over large result sets.

The way I read that, which may be wrong, is that any changes made to the dataset will be taken into account when the `next()` call is made. However, the result I'm getting is that value produced by `next()` is _cached_ from the previous call, not _retrieved_ during the current call. Here is some minimal code to reproduce and `assert` the values.


```python
import peewee

database = peewee.SqliteDatabase(":memory:")

class BaseModel(peewee.Model):
    class Meta:
        database = database
class A(BaseModel):
    """test"""

database.create_tables((A,))

# Create three records.
for _ in range(3):
    A.create()
assert len(A) == 3 # Sanity check.

# Create the generator object.
iter_query = A.select().iterator()

# Deleting more than 1-next() away doesn't return the record.
A.delete_by_id(3)

# Deleting record right before next still returns the deleted record.
A.delete_by_id(1)
assert next(iter_query).id == 1

# Next record returned even though the table is empty.
A.delete_by_id(2)
assert len(A) == 0
assert next(iter_query).id == 2

# Deleted more than 1-next() away, the record isn't retrieved.
try:
    next(iter_query)
    assert 0
except StopIteration:
    print("Stop Reached")

```