An InterfaceError was not catched only in PostgreSQLDatabase
Why are you closing the connection in the middle of iterating over a cursor? That makes no sense. This is only a reproducing. The problem is this issue often happened because some network fault so the connection was closed in the middle of iterating. 

It is only happened between two different city's database connection in our company, and we can't make the connection much better. Gotcha -- you'll probably need to implement this on your end as some kind of "re-connecting" logic. But as far as integrating into peewee, that's above-and-beyond the scope of the project. OK, I see.
I have searched this issue, and it looks like #334 

I can reproduce this problem by this code:

```python
from a_postgresql_module import MyModel

for instance in MyModel.select():
    print instance.id
    MyModel._meta.database.close()
```

This issue seems like postgresql will close a cursor automatically after the connection was closed by any reason, for example between a long time iteration, if something bad was happened so the connection was accidentally closed, and the cursor can't be re-opened. mysql doesn't have this problem, because its cursor never be closed.

I have a bad idea to solve that:

```python
class QueryResultWrapper(object):
    def __init__(self, model, cursor, meta=None, query=None):
        ...
        self.query=query
        ...

    def iterate(self):
        try:
            row = self.cursor.fetchone()
        except psycopg2.InterfaceError:
            self.cursor = self.query.execute().cursor
            row = self.cursor.fetchone()
            while row and self.process_row(row) in self._result_cache:
                row = self.cursor.fetchone()
        ...

class SelectQuery(Query):
    ...
    def execute(self):
        if self._dirty or self._qr is None:
            ...
            self._qr = ResultWrapper(model_class, self._execute(), query_meta, self)
            ...
        ...
```

That means if the error was happened, I will try to rebuild a cursor, and go to the last iterated point. Be easy to see, this is a bad class structure. And if someone else insert a new row between the old result wrapper's caches, the result will be wrong. Another way to avoid this error is fetching all the data one times. But both these two ideas are not the best choice.

So what's your idea? Or just wrap this error and add this case to the document and tell any developers to catch it in their own tools?