diff --git a/psycopg/connection_int.c b/psycopg/connection_int.c
index c05f48ee..8e5e937a 100644
--- a/psycopg/connection_int.c
+++ b/psycopg/connection_int.c
@@ -651,7 +651,6 @@ conn_is_datestyle_ok(PGconn *pgconn)
 RAISES_NEG int
 conn_setup(connectionObject *self, PGconn *pgconn)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     int rv = -1;
 
@@ -678,11 +677,10 @@ conn_setup(connectionObject *self, PGconn *pgconn)
     if (!dsn_has_replication(self->dsn) && !conn_is_datestyle_ok(self->pgconn)) {
         int res;
         Py_UNBLOCK_THREADS;
-        res = pq_set_guc_locked(self, "datestyle", "ISO",
-            &pgres, &error, &_save);
+        res = pq_set_guc_locked(self, "datestyle", "ISO", &error, &_save);
         Py_BLOCK_THREADS;
         if (res < 0) {
-            pq_complete_error(self, &pgres, &error);
+            pq_complete_error(self, &error);
             goto unlock;
         }
     }
@@ -1225,7 +1223,6 @@ conn_set_session(connectionObject *self, int autocommit,
         int isolevel, int readonly, int deferrable)
 {
     int rv = -1;
-    PGresult *pgres = NULL;
     char *error = NULL;
     int want_autocommit = autocommit == SRV_STATE_UNCHANGED ?
         self->autocommit : autocommit;
@@ -1256,21 +1253,21 @@ conn_set_session(connectionObject *self, int autocommit,
         if (isolevel != SRV_STATE_UNCHANGED) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_isolation", srv_isolevels[isolevel],
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
         if (readonly != SRV_STATE_UNCHANGED) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_read_only", srv_state_guc[readonly],
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
         if (deferrable != SRV_STATE_UNCHANGED) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_deferrable", srv_state_guc[deferrable],
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
@@ -1281,21 +1278,21 @@ conn_set_session(connectionObject *self, int autocommit,
         if (self->isolevel != ISOLATION_LEVEL_DEFAULT) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_isolation", "default",
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
         if (self->readonly != STATE_DEFAULT) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_read_only", "default",
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
         if (self->server_version >= 90100 && self->deferrable != STATE_DEFAULT) {
             if (0 > pq_set_guc_locked(self,
                     "default_transaction_deferrable", "default",
-                    &pgres, &error, &_save)) {
+                    &error, &_save)) {
                 goto endlock;
             }
         }
@@ -1320,7 +1317,7 @@ endlock:
     Py_END_ALLOW_THREADS;
 
     if (rv < 0) {
-        pq_complete_error(self, &pgres, &error);
+        pq_complete_error(self, &error);
         goto exit;
     }
 
@@ -1339,7 +1336,6 @@ exit:
 RAISES_NEG int
 conn_set_client_encoding(connectionObject *self, const char *pgenc)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     int res = -1;
     char *clean_enc = NULL;
@@ -1356,12 +1352,12 @@ conn_set_client_encoding(connectionObject *self, const char *pgenc)
 
     /* abort the current transaction, to set the encoding ouside of
        transactions */
-    if ((res = pq_abort_locked(self, &pgres, &error, &_save))) {
+    if ((res = pq_abort_locked(self, &error, &_save))) {
         goto endlock;
     }
 
     if ((res = pq_set_guc_locked(self, "client_encoding", clean_enc,
-            &pgres, &error, &_save))) {
+            &error, &_save))) {
         goto endlock;
     }
 
@@ -1370,7 +1366,7 @@ endlock:
     Py_END_ALLOW_THREADS;
 
     if (res < 0) {
-        pq_complete_error(self, &pgres, &error);
+        pq_complete_error(self, &error);
         goto exit;
     }
 
@@ -1396,7 +1392,6 @@ exit:
 RAISES_NEG int
 conn_tpc_begin(connectionObject *self, xidObject *xid)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Dprintf("conn_tpc_begin: starting transaction");
@@ -1404,10 +1399,10 @@ conn_tpc_begin(connectionObject *self, xidObject *xid)
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&self->lock);
 
-    if (pq_begin_locked(self, &pgres, &error, &_save) < 0) {
+    if (pq_begin_locked(self, &error, &_save) < 0) {
         pthread_mutex_unlock(&(self->lock));
         Py_BLOCK_THREADS;
-        pq_complete_error(self, &pgres, &error);
+        pq_complete_error(self, &error);
         return -1;
     }
 
@@ -1430,7 +1425,6 @@ conn_tpc_begin(connectionObject *self, xidObject *xid)
 RAISES_NEG int
 conn_tpc_command(connectionObject *self, const char *cmd, xidObject *xid)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     PyObject *tid = NULL;
     const char *ctid;
@@ -1446,10 +1440,10 @@ conn_tpc_command(connectionObject *self, const char *cmd, xidObject *xid)
     pthread_mutex_lock(&self->lock);
 
     if (0 > (rv = pq_tpc_command_locked(self, cmd, ctid,
-                                        &pgres, &error, &_save))) {
+                                        &error, &_save))) {
         pthread_mutex_unlock(&self->lock);
         Py_BLOCK_THREADS;
-        pq_complete_error(self, &pgres, &error);
+        pq_complete_error(self, &error);
         goto exit;
     }
 
diff --git a/psycopg/lobject_int.c b/psycopg/lobject_int.c
index ebfd697e..e0b375ad 100644
--- a/psycopg/lobject_int.c
+++ b/psycopg/lobject_int.c
@@ -150,7 +150,6 @@ lobject_open(lobjectObject *self, connectionObject *conn,
               Oid oid, const char *smode, Oid new_oid, const char *new_file)
 {
     int retvalue = -1;
-    PGresult *pgres = NULL;
     char *error = NULL;
     int pgmode = 0;
     int mode;
@@ -162,7 +161,7 @@ lobject_open(lobjectObject *self, connectionObject *conn,
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&(self->conn->lock));
 
-    retvalue = pq_begin_locked(self->conn, &pgres, &error, &_save);
+    retvalue = pq_begin_locked(self->conn, &error, &_save);
     if (retvalue < 0)
         goto end;
 
@@ -228,7 +227,7 @@ lobject_open(lobjectObject *self, connectionObject *conn,
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     /* if retvalue > 0, an exception is already set */
 
     return retvalue;
@@ -272,7 +271,6 @@ lobject_close_locked(lobjectObject *self, char **error)
 RAISES_NEG int
 lobject_close(lobjectObject *self)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     int retvalue;
 
@@ -285,7 +283,7 @@ lobject_close(lobjectObject *self)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return retvalue;
 }
 
@@ -294,14 +292,13 @@ lobject_close(lobjectObject *self)
 RAISES_NEG int
 lobject_unlink(lobjectObject *self)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     int retvalue = -1;
 
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&(self->conn->lock));
 
-    retvalue = pq_begin_locked(self->conn, &pgres, &error, &_save);
+    retvalue = pq_begin_locked(self->conn, &error, &_save);
     if (retvalue < 0)
         goto end;
 
@@ -319,7 +316,7 @@ lobject_unlink(lobjectObject *self)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return retvalue;
 }
 
@@ -329,7 +326,6 @@ RAISES_NEG Py_ssize_t
 lobject_write(lobjectObject *self, const char *buf, size_t len)
 {
     Py_ssize_t written;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Dprintf("lobject_writing: fd = %d, len = " FORMAT_CODE_SIZE_T,
@@ -346,7 +342,7 @@ lobject_write(lobjectObject *self, const char *buf, size_t len)
     Py_END_ALLOW_THREADS;
 
     if (written < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return written;
 }
 
@@ -356,7 +352,6 @@ RAISES_NEG Py_ssize_t
 lobject_read(lobjectObject *self, char *buf, size_t len)
 {
     Py_ssize_t n_read;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Py_BEGIN_ALLOW_THREADS;
@@ -370,7 +365,7 @@ lobject_read(lobjectObject *self, char *buf, size_t len)
     Py_END_ALLOW_THREADS;
 
     if (n_read < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return n_read;
 }
 
@@ -379,7 +374,6 @@ lobject_read(lobjectObject *self, char *buf, size_t len)
 RAISES_NEG Py_ssize_t
 lobject_seek(lobjectObject *self, Py_ssize_t pos, int whence)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     Py_ssize_t where;
 
@@ -406,7 +400,7 @@ lobject_seek(lobjectObject *self, Py_ssize_t pos, int whence)
     Py_END_ALLOW_THREADS;
 
     if (where < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return where;
 }
 
@@ -415,7 +409,6 @@ lobject_seek(lobjectObject *self, Py_ssize_t pos, int whence)
 RAISES_NEG Py_ssize_t
 lobject_tell(lobjectObject *self)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     Py_ssize_t where;
 
@@ -441,7 +434,7 @@ lobject_tell(lobjectObject *self)
     Py_END_ALLOW_THREADS;
 
     if (where < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return where;
 }
 
@@ -450,14 +443,13 @@ lobject_tell(lobjectObject *self)
 RAISES_NEG int
 lobject_export(lobjectObject *self, const char *filename)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
     int retvalue;
 
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&(self->conn->lock));
 
-    retvalue = pq_begin_locked(self->conn, &pgres, &error, &_save);
+    retvalue = pq_begin_locked(self->conn, &error, &_save);
     if (retvalue < 0)
         goto end;
 
@@ -470,7 +462,7 @@ lobject_export(lobjectObject *self, const char *filename)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return retvalue;
 }
 
@@ -478,7 +470,6 @@ RAISES_NEG int
 lobject_truncate(lobjectObject *self, size_t len)
 {
     int retvalue;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Dprintf("lobject_truncate: fd = %d, len = " FORMAT_CODE_SIZE_T,
@@ -504,7 +495,7 @@ lobject_truncate(lobjectObject *self, size_t len)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(self->conn, &pgres, &error);
+        pq_complete_error(self->conn, &error);
     return retvalue;
 
 }
diff --git a/psycopg/pqpath.c b/psycopg/pqpath.c
index cb1c603e..722a6ae6 100644
--- a/psycopg/pqpath.c
+++ b/psycopg/pqpath.c
@@ -305,7 +305,7 @@ pq_set_non_blocking(connectionObject *conn, int arg)
    This function should only be called on a locked connection without
    holding the global interpreter lock.
 
-   On error, -1 is returned, and the pgres argument will hold the
+   On error, -1 is returned, and the conn->pgres will hold the
    relevant result structure.
 
    The tstate parameter should be the pointer of the _save variable created by
@@ -314,23 +314,22 @@ pq_set_non_blocking(connectionObject *conn, int arg)
  */
 int
 pq_execute_command_locked(connectionObject *conn, const char *query,
-                          PGresult **pgres, char **error,
-                          PyThreadState **tstate)
+                          char **error, PyThreadState **tstate)
 {
     int pgstatus, retvalue = -1;
-
     Dprintf("pq_execute_command_locked: pgconn = %p, query = %s",
             conn->pgconn, query);
     *error = NULL;
 
+    CLEARPGRES(conn->pgres);
     if (!psyco_green()) {
-        *pgres = PQexec(conn->pgconn, query);
+        conn->pgres = PQexec(conn->pgconn, query);
     } else {
         PyEval_RestoreThread(*tstate);
-        *pgres = psyco_exec_green(conn, query);
+        conn->pgres = psyco_exec_green(conn, query);
         *tstate = PyEval_SaveThread();
     }
-    if (*pgres == NULL) {
+    if (conn->pgres == NULL) {
         Dprintf("pq_execute_command_locked: PQexec returned NULL");
         PyEval_RestoreThread(*tstate);
         if (!PyErr_Occurred()) {
@@ -342,7 +341,7 @@ pq_execute_command_locked(connectionObject *conn, const char *query,
         goto cleanup;
     }
 
-    pgstatus = PQresultStatus(*pgres);
+    pgstatus = PQresultStatus(conn->pgres);
     if (pgstatus != PGRES_COMMAND_OK ) {
         Dprintf("pq_execute_command_locked: result was not COMMAND_OK (%d)",
                 pgstatus);
@@ -350,7 +349,7 @@ pq_execute_command_locked(connectionObject *conn, const char *query,
     }
 
     retvalue = 0;
-    CLEARPGRES(*pgres);
+    CLEARPGRES(conn->pgres);
 
 cleanup:
     return retvalue;
@@ -365,13 +364,13 @@ cleanup:
    lock.
  */
 RAISES void
-pq_complete_error(connectionObject *conn, PGresult **pgres, char **error)
+pq_complete_error(connectionObject *conn, char **error)
 {
     Dprintf("pq_complete_error: pgconn = %p, pgres = %p, error = %s",
-            conn->pgconn, *pgres, *error ? *error : "(null)");
-    if (*pgres != NULL) {
-        pq_raise(conn, NULL, pgres);
-        /* now *pgres is null */
+            conn->pgconn, conn->pgres, *error ? *error : "(null)");
+    if (conn->pgres) {
+        pq_raise(conn, NULL, &conn->pgres);
+        /* now conn->pgres is null */
     }
     else {
         if (*error != NULL) {
@@ -405,11 +404,11 @@ pq_complete_error(connectionObject *conn, PGresult **pgres, char **error)
    This function should only be called on a locked connection without
    holding the global interpreter lock.
 
-   On error, -1 is returned, and the pgres argument will hold the
+   On error, -1 is returned, and the conn->pgres argument will hold the
    relevant result structure.
  */
 int
-pq_begin_locked(connectionObject *conn, PGresult **pgres, char **error,
+pq_begin_locked(connectionObject *conn, char **error,
                 PyThreadState **tstate)
 {
     const size_t bufsize = 256;
@@ -441,7 +440,7 @@ pq_begin_locked(connectionObject *conn, PGresult **pgres, char **error,
             srv_deferrable[conn->deferrable]);
     }
 
-    result = pq_execute_command_locked(conn, buf, pgres, error, tstate);
+    result = pq_execute_command_locked(conn, buf, error, tstate);
     if (result == 0)
         conn->status = CONN_STATUS_BEGIN;
 
@@ -458,7 +457,6 @@ int
 pq_commit(connectionObject *conn)
 {
     int retvalue = -1;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Py_BEGIN_ALLOW_THREADS;
@@ -473,7 +471,7 @@ pq_commit(connectionObject *conn)
     }
     else {
         conn->mark += 1;
-        retvalue = pq_execute_command_locked(conn, "COMMIT", &pgres, &error, &_save);
+        retvalue = pq_execute_command_locked(conn, "COMMIT", &error, &_save);
     }
 
     Py_BLOCK_THREADS;
@@ -488,13 +486,13 @@ pq_commit(connectionObject *conn)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(conn, &pgres, &error);
+        pq_complete_error(conn, &error);
 
     return retvalue;
 }
 
 RAISES_NEG int
-pq_abort_locked(connectionObject *conn, PGresult **pgres, char **error,
+pq_abort_locked(connectionObject *conn, char **error,
                 PyThreadState **tstate)
 {
     int retvalue = -1;
@@ -508,7 +506,7 @@ pq_abort_locked(connectionObject *conn, PGresult **pgres, char **error,
     }
 
     conn->mark += 1;
-    retvalue = pq_execute_command_locked(conn, "ROLLBACK", pgres, error, tstate);
+    retvalue = pq_execute_command_locked(conn, "ROLLBACK", error, tstate);
     if (retvalue == 0)
         conn->status = CONN_STATUS_READY;
 
@@ -524,7 +522,6 @@ RAISES_NEG int
 pq_abort(connectionObject *conn)
 {
     int retvalue = -1;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Dprintf("pq_abort: pgconn = %p, autocommit = %d, status = %d",
@@ -533,7 +530,7 @@ pq_abort(connectionObject *conn)
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&conn->lock);
 
-    retvalue = pq_abort_locked(conn, &pgres, &error, &_save);
+    retvalue = pq_abort_locked(conn, &error, &_save);
 
     Py_BLOCK_THREADS;
     conn_notice_process(conn);
@@ -543,7 +540,7 @@ pq_abort(connectionObject *conn)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0)
-        pq_complete_error(conn, &pgres, &error);
+        pq_complete_error(conn, &error);
 
     return retvalue;
 }
@@ -558,8 +555,7 @@ pq_abort(connectionObject *conn)
 */
 
 RAISES_NEG int
-pq_reset_locked(connectionObject *conn, PGresult **pgres, char **error,
-                PyThreadState **tstate)
+pq_reset_locked(connectionObject *conn, char **error, PyThreadState **tstate)
 {
     int retvalue = -1;
 
@@ -569,20 +565,20 @@ pq_reset_locked(connectionObject *conn, PGresult **pgres, char **error,
     conn->mark += 1;
 
     if (!conn->autocommit && conn->status == CONN_STATUS_BEGIN) {
-        retvalue = pq_execute_command_locked(conn, "ABORT", pgres, error, tstate);
+        retvalue = pq_execute_command_locked(conn, "ABORT", error, tstate);
         if (retvalue != 0) return retvalue;
     }
 
     if (conn->server_version >= 80300) {
-        retvalue = pq_execute_command_locked(conn, "DISCARD ALL", pgres, error, tstate);
+        retvalue = pq_execute_command_locked(conn, "DISCARD ALL", error, tstate);
         if (retvalue != 0) return retvalue;
     }
     else {
-        retvalue = pq_execute_command_locked(conn, "RESET ALL", pgres, error, tstate);
+        retvalue = pq_execute_command_locked(conn, "RESET ALL", error, tstate);
         if (retvalue != 0) return retvalue;
 
         retvalue = pq_execute_command_locked(conn,
-            "SET SESSION AUTHORIZATION DEFAULT", pgres, error, tstate);
+            "SET SESSION AUTHORIZATION DEFAULT", error, tstate);
         if (retvalue != 0) return retvalue;
     }
 
@@ -596,7 +592,6 @@ int
 pq_reset(connectionObject *conn)
 {
     int retvalue = -1;
-    PGresult *pgres = NULL;
     char *error = NULL;
 
     Dprintf("pq_reset: pgconn = %p, autocommit = %d, status = %d",
@@ -605,7 +600,7 @@ pq_reset(connectionObject *conn)
     Py_BEGIN_ALLOW_THREADS;
     pthread_mutex_lock(&conn->lock);
 
-    retvalue = pq_reset_locked(conn, &pgres, &error, &_save);
+    retvalue = pq_reset_locked(conn, &error, &_save);
 
     Py_BLOCK_THREADS;
     conn_notice_process(conn);
@@ -615,7 +610,7 @@ pq_reset(connectionObject *conn)
     Py_END_ALLOW_THREADS;
 
     if (retvalue < 0) {
-        pq_complete_error(conn, &pgres, &error);
+        pq_complete_error(conn, &error);
     }
     else {
         Py_CLEAR(conn->tpc_xid);
@@ -635,7 +630,7 @@ pq_reset(connectionObject *conn)
 char *
 pq_get_guc_locked(
     connectionObject *conn, const char *param,
-    PGresult **pgres, char **error, PyThreadState **tstate)
+    char **error, PyThreadState **tstate)
 {
     char query[256];
     int size;
@@ -652,15 +647,17 @@ pq_get_guc_locked(
     Dprintf("pq_get_guc_locked: pgconn = %p, query = %s", conn->pgconn, query);
 
     *error = NULL;
+    CLEARPGRES(conn->pgres);
+
     if (!psyco_green()) {
-        *pgres = PQexec(conn->pgconn, query);
+        conn->pgres = PQexec(conn->pgconn, query);
     } else {
         PyEval_RestoreThread(*tstate);
-        *pgres = psyco_exec_green(conn, query);
+        conn->pgres = psyco_exec_green(conn, query);
         *tstate = PyEval_SaveThread();
     }
 
-    if (*pgres == NULL) {
+    if (!conn->pgres) {
         Dprintf("pq_get_guc_locked: PQexec returned NULL");
         PyEval_RestoreThread(*tstate);
         if (!PyErr_Occurred()) {
@@ -671,14 +668,14 @@ pq_get_guc_locked(
         *tstate = PyEval_SaveThread();
         goto cleanup;
     }
-    if (PQresultStatus(*pgres) != PGRES_TUPLES_OK) {
-        Dprintf("pq_get_guc_locked: result was not TUPLES_OK (%d)",
-                PQresultStatus(*pgres));
+    if (PQresultStatus(conn->pgres) != PGRES_TUPLES_OK) {
+        Dprintf("pq_get_guc_locked: result was not TUPLES_OK (%s)",
+                PQresStatus(PQresultStatus(conn->pgres)));
         goto cleanup;
     }
 
-    rv = strdup(PQgetvalue(*pgres, 0, 0));
-    CLEARPGRES(*pgres);
+    rv = strdup(PQgetvalue(conn->pgres, 0, 0));
+    CLEARPGRES(conn->pgres);
 
 cleanup:
     return rv;
@@ -693,7 +690,7 @@ cleanup:
 int
 pq_set_guc_locked(
     connectionObject *conn, const char *param, const char *value,
-    PGresult **pgres, char **error, PyThreadState **tstate)
+    char **error, PyThreadState **tstate)
 {
     char query[256];
     int size;
@@ -714,7 +711,7 @@ pq_set_guc_locked(
         goto exit;
     }
 
-    rv = pq_execute_command_locked(conn, query, pgres, error, tstate);
+    rv = pq_execute_command_locked(conn, query, error, tstate);
 
 exit:
     return rv;
@@ -727,7 +724,7 @@ exit:
 
 int
 pq_tpc_command_locked(connectionObject *conn, const char *cmd, const char *tid,
-                  PGresult **pgres, char **error, PyThreadState **tstate)
+                  char **error, PyThreadState **tstate)
 {
     int rv = -1;
     char *etid = NULL, *buf = NULL;
@@ -754,7 +751,7 @@ pq_tpc_command_locked(connectionObject *conn, const char *cmd, const char *tid,
 
     /* run the command and let it handle the error cases */
     *tstate = PyEval_SaveThread();
-    rv = pq_execute_command_locked(conn, buf, pgres, error, tstate);
+    rv = pq_execute_command_locked(conn, buf, error, tstate);
     PyEval_RestoreThread(*tstate);
 
 exit:
@@ -769,7 +766,7 @@ exit:
 /* pq_get_result_async - read an available result without blocking.
  *
  * Return 0 if the result is ready, 1 if it will block, -1 on error.
- * The last result will be returned in pgres.
+ * The last result will be returned in conn->pgres.
  *
  * The function should be called with the lock and holding the GIL.
  */
@@ -891,42 +888,43 @@ pq_flush(connectionObject *conn)
 RAISES_NEG int
 _pq_execute_sync(cursorObject *curs, const char *query, int no_result, int no_begin)
 {
-    PGresult *pgres = NULL;
     char *error = NULL;
+    connectionObject *conn = curs->conn;
 
     CLEARPGRES(curs->pgres);
 
     Py_BEGIN_ALLOW_THREADS;
-    pthread_mutex_lock(&(curs->conn->lock));
+    pthread_mutex_lock(&(conn->lock));
 
-    if (!no_begin && pq_begin_locked(curs->conn, &pgres, &error, &_save) < 0) {
-        pthread_mutex_unlock(&(curs->conn->lock));
+    if (!no_begin && pq_begin_locked(conn, &error, &_save) < 0) {
+        pthread_mutex_unlock(&(conn->lock));
         Py_BLOCK_THREADS;
-        pq_complete_error(curs->conn, &pgres, &error);
+        pq_complete_error(conn, &error);
         return -1;
     }
 
-    Dprintf("pq_execute: executing SYNC query: pgconn = %p", curs->conn->pgconn);
+    CLEARPGRES(conn->pgres);
+    Dprintf("pq_execute: executing SYNC query: pgconn = %p", conn->pgconn);
     Dprintf("    %-.200s", query);
     if (!psyco_green()) {
-        pgres = PQexec(curs->conn->pgconn, query);
+        conn->pgres = PQexec(conn->pgconn, query);
     }
     else {
         Py_BLOCK_THREADS;
-        pgres = psyco_exec_green(curs->conn, query);
+        conn->pgres = psyco_exec_green(conn, query);
         Py_UNBLOCK_THREADS;
     }
 
     /* don't let pgres = NULL go to pq_fetch() */
-    if (pgres == NULL) {
-        if (CONNECTION_BAD == PQstatus(curs->conn->pgconn)) {
-            curs->conn->closed = 2;
+    if (!conn->pgres) {
+        if (CONNECTION_BAD == PQstatus(conn->pgconn)) {
+            conn->closed = 2;
         }
-        pthread_mutex_unlock(&(curs->conn->lock));
+        pthread_mutex_unlock(&(conn->lock));
         Py_BLOCK_THREADS;
         if (!PyErr_Occurred()) {
             PyErr_SetString(OperationalError,
-                            PQerrorMessage(curs->conn->pgconn));
+                            PQerrorMessage(conn->pgconn));
         }
         return -1;
     }
@@ -934,18 +932,18 @@ _pq_execute_sync(cursorObject *curs, const char *query, int no_result, int no_be
     Py_BLOCK_THREADS;
 
     /* assign the result back to the cursor now that we have the GIL */
-    curs->pgres = pgres;
-    pgres = NULL;
+    curs->pgres = conn->pgres;
+    conn->pgres = NULL;
 
     /* Process notifies here instead of when fetching the tuple as we are
      * into the same critical section that received the data. Without this
      * care, reading notifies may disrupt other thread communications.
      * (as in ticket #55). */
-    conn_notifies_process(curs->conn);
-    conn_notice_process(curs->conn);
+    conn_notifies_process(conn);
+    conn_notice_process(conn);
     Py_UNBLOCK_THREADS;
 
-    pthread_mutex_unlock(&(curs->conn->lock));
+    pthread_mutex_unlock(&(conn->lock));
     Py_END_ALLOW_THREADS;
 
     /* if the execute was sync, we call pq_fetch() immediately,
@@ -960,29 +958,30 @@ RAISES_NEG int
 _pq_execute_async(cursorObject *curs, const char *query, int no_result)
 {
     int async_status = ASYNC_WRITE;
+    connectionObject *conn = curs->conn;
     int ret;
 
     CLEARPGRES(curs->pgres);
 
     Py_BEGIN_ALLOW_THREADS;
-    pthread_mutex_lock(&(curs->conn->lock));
+    pthread_mutex_lock(&(conn->lock));
 
-    Dprintf("pq_execute: executing ASYNC query: pgconn = %p", curs->conn->pgconn);
+    Dprintf("pq_execute: executing ASYNC query: pgconn = %p", conn->pgconn);
     Dprintf("    %-.200s", query);
 
-    if (PQsendQuery(curs->conn->pgconn, query) == 0) {
-        if (CONNECTION_BAD == PQstatus(curs->conn->pgconn)) {
-            curs->conn->closed = 2;
+    if (PQsendQuery(conn->pgconn, query) == 0) {
+        if (CONNECTION_BAD == PQstatus(conn->pgconn)) {
+            conn->closed = 2;
         }
-        pthread_mutex_unlock(&(curs->conn->lock));
+        pthread_mutex_unlock(&(conn->lock));
         Py_BLOCK_THREADS;
         PyErr_SetString(OperationalError,
-                        PQerrorMessage(curs->conn->pgconn));
+                        PQerrorMessage(conn->pgconn));
         return -1;
     }
     Dprintf("pq_execute: async query sent to backend");
 
-    ret = PQflush(curs->conn->pgconn);
+    ret = PQflush(conn->pgconn);
     if (ret == 0) {
         /* the query got fully sent to the server */
         Dprintf("pq_execute: query got flushed immediately");
@@ -995,18 +994,18 @@ _pq_execute_async(cursorObject *curs, const char *query, int no_result)
     }
     else {
         /* there was an error */
-        pthread_mutex_unlock(&(curs->conn->lock));
+        pthread_mutex_unlock(&(conn->lock));
         Py_BLOCK_THREADS;
         PyErr_SetString(OperationalError,
-                        PQerrorMessage(curs->conn->pgconn));
+                        PQerrorMessage(conn->pgconn));
         return -1;
     }
 
-    pthread_mutex_unlock(&(curs->conn->lock));
+    pthread_mutex_unlock(&(conn->lock));
     Py_END_ALLOW_THREADS;
 
-    curs->conn->async_status = async_status;
-    if (!(curs->conn->async_cursor
+    conn->async_status = async_status;
+    if (!(conn->async_cursor
             = PyWeakref_NewRef((PyObject *)curs, NULL))) {
         return -1;
     }
diff --git a/psycopg/pqpath.h b/psycopg/pqpath.h
index 0ad74d97..7fb007f5 100644
--- a/psycopg/pqpath.h
+++ b/psycopg/pqpath.h
@@ -39,25 +39,23 @@ RAISES_NEG HIDDEN int pq_fetch(cursorObject *curs, int no_result);
 RAISES_NEG HIDDEN int pq_execute(cursorObject *curs, const char *query,
                                  int async, int no_result, int no_begin);
 HIDDEN int pq_send_query(connectionObject *conn, const char *query);
-HIDDEN int pq_begin_locked(connectionObject *conn, PGresult **pgres,
+HIDDEN int pq_begin_locked(connectionObject *conn,
                            char **error, PyThreadState **tstate);
 HIDDEN int pq_commit(connectionObject *conn);
-RAISES_NEG HIDDEN int pq_abort_locked(connectionObject *conn, PGresult **pgres,
+RAISES_NEG HIDDEN int pq_abort_locked(connectionObject *conn,
                            char **error, PyThreadState **tstate);
 RAISES_NEG HIDDEN int pq_abort(connectionObject *conn);
-HIDDEN int pq_reset_locked(connectionObject *conn, PGresult **pgres,
+HIDDEN int pq_reset_locked(connectionObject *conn,
                             char **error, PyThreadState **tstate);
 RAISES_NEG HIDDEN int pq_reset(connectionObject *conn);
 HIDDEN char *pq_get_guc_locked(connectionObject *conn, const char *param,
-                               PGresult **pgres,
                                char **error, PyThreadState **tstate);
 HIDDEN int pq_set_guc_locked(connectionObject *conn, const char *param,
-                             const char *value, PGresult **pgres,
+                             const char *value,
                              char **error, PyThreadState **tstate);
 HIDDEN int pq_tpc_command_locked(connectionObject *conn,
                                  const char *cmd, const char *tid,
-                                 PGresult **pgres, char **error,
-                                 PyThreadState **tstate);
+                                 char **error, PyThreadState **tstate);
 RAISES_NEG HIDDEN int pq_get_result_async(connectionObject *conn);
 HIDDEN int pq_flush(connectionObject *conn);
 HIDDEN void pq_clear_async(connectionObject *conn);
@@ -67,10 +65,9 @@ HIDDEN void pq_set_critical(connectionObject *conn, const char *msg);
 
 HIDDEN int pq_execute_command_locked(connectionObject *conn,
                                      const char *query,
-                                     PGresult **pgres, char **error,
+                                     char **error,
                                      PyThreadState **tstate);
-RAISES HIDDEN void pq_complete_error(connectionObject *conn, PGresult **pgres,
-                              char **error);
+RAISES HIDDEN void pq_complete_error(connectionObject *conn, char **error);
 
 /* replication protocol support */
 HIDDEN int pq_copy_both(replicationCursorObject *repl, PyObject *consumer,