add auto reconnect for postgres

This only works on the second database interaction, since psycopg2 only notices that
the connection is gone, when a query is executed.

So in the common case reconnect works as follows:
- some bot method calls a cursor function like .execute(), .fetchone(), etc.
  - this raises an error if the connection is broken
  - if following code then requests a new cursor, this will also fail since psycopg2
    now knows that the connection is gone
  - the error is caught in storage.DBConn.cursor(), a new connection will be set up
    of which a new cursor is yielded
If the error happens in connection.commit() or .rollback() instead we can instantly
reconnect since these methods are wrapped.

So why not wrap the cursor methods as well?
Consider the following example:
A query is the last thing that was executed on a cursor.
The database connection is lost.
Now .fetchone() is called on the cursor.
We could wrap .fetchone() and reconnect, but we'd have to use a new cursor since
cursors are linked to connections. And on this new cursor .fetchone() wouldn't
make any sense, since we haven't executed a query on this cursor.

bot/quotes.py

@@ -23,43 +23,45 @@ class Quotes(DatabasePlugin):
             self.bot.notice(mask.nick, '[Quotes] Error parsing nick')
         else:
             # Insert quote into database
-            self.cur.execute('''
-            INSERT INTO
-              quotes (nick, item, channel, created_by)
-            VALUES
-              (%s, %s, %s, %s)
-            ''', [nick, quote, channel, mask.nick])
+            with self.con.cursor() as cur:
+                cur.execute('''
+                INSERT INTO
+                  quotes (nick, item, channel, created_by)
+                VALUES
+                  (%s, %s, %s, %s)
+                ''', [nick, quote, channel, mask.nick])
 
     def delete_quote(self, nick: str, quote: str):
         index, order = parse_int(quote, select=False)
 
         if index:
             # Delete from database
-            self.cur.execute('''
-            -- noinspection SqlResolve
-            WITH ranked_quotes AS (
-              SELECT
-                id,
-                rank() OVER (PARTITION BY nick ORDER BY id {order})
-              FROM
-                quotes
-              WHERE
-                lower(nick) = lower(%s)
-            )
+            with self.con.cursor() as cur:
+                cur.execute('''
+                -- noinspection SqlResolve
+                WITH ranked_quotes AS (
+                  SELECT
+                    id,
+                    rank() OVER (PARTITION BY nick ORDER BY id {order})
+                  FROM
+                    quotes
+                  WHERE
+                    lower(nick) = lower(%s)
+                )
 
-            -- noinspection SqlResolve
-            DELETE FROM
-              quotes
-            WHERE
-              id = (
-                SELECT
-                  id
-                FROM
-                  ranked_quotes
+                -- noinspection SqlResolve
+                DELETE FROM
+                  quotes
                 WHERE
-                  rank = %s
-              )
-            '''.format(order=order), [nick, index])
+                  id = (
+                    SELECT
+                      id
+                    FROM
+                      ranked_quotes
+                    WHERE
+                      rank = %s
+                  )
+                '''.format(order=order), [nick, index])
 
     @command(options_first=True, quiet=True)
     def q(self, mask: IrcString, target: IrcString, args: Dict):
@@ -135,30 +137,31 @@ class Quotes(DatabasePlugin):
                 offset = ''
 
             # Fetch quote from database
-            self.cur.execute('''
-            WITH ranked_quotes AS (
-              SELECT
-                nick,
-                item,
-                rank() OVER (PARTITION BY nick ORDER BY id),
-                count(*) OVER (PARTITION BY nick) AS total
-              FROM
-                quotes
-            )
+            with self.con.cursor() as cur:
+                cur.execute('''
+                WITH ranked_quotes AS (
+                  SELECT
+                    nick,
+                    item,
+                    rank() OVER (PARTITION BY nick ORDER BY id),
+                    count(*) OVER (PARTITION BY nick) AS total
+                  FROM
+                    quotes
+                )
 
-            SELECT
-              *
-            FROM
-              ranked_quotes
-            WHERE
-              {where}
-            ORDER BY
-              {order}
-            LIMIT
-              1
-            {offset}
-            '''.format(where=' AND '.join(where), order=order, offset=offset), values)
-            result = self.cur.fetchone()
+                SELECT
+                  *
+                FROM
+                  ranked_quotes
+                WHERE
+                  {where}
+                ORDER BY
+                  {order}
+                LIMIT
+                  1
+                {offset}
+                '''.format(where=' AND '.join(where), order=order, offset=offset), values)
+                result = cur.fetchone()
 
             if result:
                 return '[{rank}/{total}] <{nick}> {item}'.format(**result)