From 17a074b30ac860647b3e42eada77d6848079d2be Mon Sep 17 00:00:00 2001 From: Daniele Varrazzo Date: Sun, 17 Mar 2019 03:38:59 +0000 Subject: [PATCH] Use the error on the connection instead of passing it explicitly around --- psycopg/connection.h | 4 +- psycopg/connection_int.c | 53 ++++++++++++----------- psycopg/connection_type.c | 1 + psycopg/lobject_int.c | 68 ++++++++++++----------------- psycopg/pqpath.c | 90 ++++++++++++++++----------------------- psycopg/pqpath.h | 21 ++++----- 6 files changed, 105 insertions(+), 132 deletions(-) diff --git a/psycopg/connection.h b/psycopg/connection.h index 6c7ade6e..7ee226c6 100644 --- a/psycopg/connection.h +++ b/psycopg/connection.h @@ -109,6 +109,7 @@ struct connectionObject { PyObject *async_cursor; int async_status; /* asynchronous execution status */ PGresult *pgres; /* temporary result across async calls */ + char *error; /* temporarily stored error before raising */ /* notice processing */ PyObject *notice_list; @@ -160,7 +161,7 @@ HIDDEN int conn_get_server_version(PGconn *pgconn); HIDDEN void conn_notice_process(connectionObject *self); HIDDEN void conn_notice_clean(connectionObject *self); HIDDEN void conn_notifies_process(connectionObject *self); -RAISES_NEG HIDDEN int conn_setup(connectionObject *self); +RAISES_NEG HIDDEN int conn_setup(connectionObject *self); HIDDEN int conn_connect(connectionObject *self, long int async); HIDDEN void conn_close(connectionObject *self); HIDDEN void conn_close_locked(connectionObject *self); @@ -175,6 +176,7 @@ RAISES_NEG HIDDEN int conn_tpc_command(connectionObject *self, const char *cmd, xidObject *xid); HIDDEN PyObject *conn_tpc_recover(connectionObject *self); HIDDEN void conn_set_result(connectionObject *self, PGresult *pgres); +HIDDEN void conn_set_error(connectionObject *self, const char *msg); /* exception-raising macros */ #define EXC_IF_CONN_CLOSED(self) if ((self)->closed > 0) { \ diff --git a/psycopg/connection_int.c b/psycopg/connection_int.c index 7c263e83..ad17e450 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) { - char *error = NULL; int rv = -1; self->equote = conn_get_standard_conforming_strings(self->pgconn); @@ -677,10 +676,10 @@ conn_setup(connectionObject *self) 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", &error, &_save); + res = pq_set_guc_locked(self, "datestyle", "ISO", &_save); Py_BLOCK_THREADS; if (res < 0) { - pq_complete_error(self, &error); + pq_complete_error(self); goto unlock; } } @@ -1221,7 +1220,6 @@ conn_set_session(connectionObject *self, int autocommit, int isolevel, int readonly, int deferrable) { int rv = -1; - char *error = NULL; int want_autocommit = autocommit == SRV_STATE_UNCHANGED ? self->autocommit : autocommit; @@ -1251,21 +1249,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], - &error, &_save)) { + &_save)) { goto endlock; } } if (readonly != SRV_STATE_UNCHANGED) { if (0 > pq_set_guc_locked(self, "default_transaction_read_only", srv_state_guc[readonly], - &error, &_save)) { + &_save)) { goto endlock; } } if (deferrable != SRV_STATE_UNCHANGED) { if (0 > pq_set_guc_locked(self, "default_transaction_deferrable", srv_state_guc[deferrable], - &error, &_save)) { + &_save)) { goto endlock; } } @@ -1276,21 +1274,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", - &error, &_save)) { + &_save)) { goto endlock; } } if (self->readonly != STATE_DEFAULT) { if (0 > pq_set_guc_locked(self, "default_transaction_read_only", "default", - &error, &_save)) { + &_save)) { goto endlock; } } if (self->server_version >= 90100 && self->deferrable != STATE_DEFAULT) { if (0 > pq_set_guc_locked(self, "default_transaction_deferrable", "default", - &error, &_save)) { + &_save)) { goto endlock; } } @@ -1315,7 +1313,7 @@ endlock: Py_END_ALLOW_THREADS; if (rv < 0) { - pq_complete_error(self, &error); + pq_complete_error(self); goto exit; } @@ -1334,7 +1332,6 @@ exit: RAISES_NEG int conn_set_client_encoding(connectionObject *self, const char *pgenc) { - char *error = NULL; int res = -1; char *clean_enc = NULL; @@ -1350,12 +1347,11 @@ 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, &error, &_save))) { + if ((res = pq_abort_locked(self, &_save))) { goto endlock; } - if ((res = pq_set_guc_locked(self, "client_encoding", clean_enc, - &error, &_save))) { + if ((res = pq_set_guc_locked(self, "client_encoding", clean_enc, &_save))) { goto endlock; } @@ -1364,7 +1360,7 @@ endlock: Py_END_ALLOW_THREADS; if (res < 0) { - pq_complete_error(self, &error); + pq_complete_error(self); goto exit; } @@ -1390,17 +1386,15 @@ exit: RAISES_NEG int conn_tpc_begin(connectionObject *self, xidObject *xid) { - char *error = NULL; - Dprintf("conn_tpc_begin: starting transaction"); Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&self->lock); - if (pq_begin_locked(self, &error, &_save) < 0) { + if (pq_begin_locked(self, &_save) < 0) { pthread_mutex_unlock(&(self->lock)); Py_BLOCK_THREADS; - pq_complete_error(self, &error); + pq_complete_error(self); return -1; } @@ -1423,7 +1417,6 @@ conn_tpc_begin(connectionObject *self, xidObject *xid) RAISES_NEG int conn_tpc_command(connectionObject *self, const char *cmd, xidObject *xid) { - char *error = NULL; PyObject *tid = NULL; const char *ctid; int rv = -1; @@ -1437,11 +1430,10 @@ conn_tpc_command(connectionObject *self, const char *cmd, xidObject *xid) Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&self->lock); - if (0 > (rv = pq_tpc_command_locked(self, cmd, ctid, - &error, &_save))) { + if (0 > (rv = pq_tpc_command_locked(self, cmd, ctid, &_save))) { pthread_mutex_unlock(&self->lock); Py_BLOCK_THREADS; - pq_complete_error(self, &error); + pq_complete_error(self); goto exit; } @@ -1494,3 +1486,16 @@ conn_set_result(connectionObject *self, PGresult *pgres) PQclear(self->pgres); self->pgres = pgres; } + + +void +conn_set_error(connectionObject *self, const char *msg) +{ + if (self->error) { + free(self->error); + self->error = NULL; + } + if (msg && *msg) { + self->error = strdup(msg); + } +} diff --git a/psycopg/connection_type.c b/psycopg/connection_type.c index 5f4bd1c2..8249b29b 100644 --- a/psycopg/connection_type.c +++ b/psycopg/connection_type.c @@ -1430,6 +1430,7 @@ connection_dealloc(PyObject* obj) PyMem_Free(self->dsn); PyMem_Free(self->encoding); + if (self->error) free(self->error); if (self->critical) free(self->critical); if (self->cancel) PQfreeCancel(self->cancel); PQclear(self->pgres); diff --git a/psycopg/lobject_int.c b/psycopg/lobject_int.c index e0b375ad..a14faef7 100644 --- a/psycopg/lobject_int.c +++ b/psycopg/lobject_int.c @@ -33,12 +33,9 @@ #include static void -collect_error(connectionObject *conn, char **error) +collect_error(connectionObject *conn) { - const char *msg = PQerrorMessage(conn->pgconn); - - if (msg) - *error = strdup(msg); + conn_set_error(conn, PQerrorMessage(conn->pgconn)); } @@ -150,7 +147,6 @@ lobject_open(lobjectObject *self, connectionObject *conn, Oid oid, const char *smode, Oid new_oid, const char *new_file) { int retvalue = -1; - char *error = NULL; int pgmode = 0; int mode; @@ -161,7 +157,7 @@ lobject_open(lobjectObject *self, connectionObject *conn, Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(self->conn->lock)); - retvalue = pq_begin_locked(self->conn, &error, &_save); + retvalue = pq_begin_locked(self->conn, &_save); if (retvalue < 0) goto end; @@ -184,7 +180,7 @@ lobject_open(lobjectObject *self, connectionObject *conn, self->oid); if (self->oid == InvalidOid) { - collect_error(self->conn, &error); + collect_error(self->conn); retvalue = -1; goto end; } @@ -204,7 +200,7 @@ lobject_open(lobjectObject *self, connectionObject *conn, pgmode, self->fd); if (self->fd == -1) { - collect_error(self->conn, &error); + collect_error(self->conn); retvalue = -1; goto end; } @@ -227,7 +223,7 @@ lobject_open(lobjectObject *self, connectionObject *conn, Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); /* if retvalue > 0, an exception is already set */ return retvalue; @@ -236,7 +232,7 @@ lobject_open(lobjectObject *self, connectionObject *conn, /* lobject_close - close an existing lo */ RAISES_NEG static int -lobject_close_locked(lobjectObject *self, char **error) +lobject_close_locked(lobjectObject *self) { int retvalue; @@ -250,7 +246,7 @@ lobject_close_locked(lobjectObject *self, char **error) return 0; break; default: - *error = strdup("the connection is broken"); + conn_set_error(self->conn, "the connection is broken"); return -1; break; } @@ -263,7 +259,7 @@ lobject_close_locked(lobjectObject *self, char **error) retvalue = lo_close(self->conn->pgconn, self->fd); self->fd = -1; if (retvalue < 0) - collect_error(self->conn, error); + collect_error(self->conn); return retvalue; } @@ -271,19 +267,18 @@ lobject_close_locked(lobjectObject *self, char **error) RAISES_NEG int lobject_close(lobjectObject *self) { - char *error = NULL; int retvalue; Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(self->conn->lock)); - retvalue = lobject_close_locked(self, &error); + retvalue = lobject_close_locked(self); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return retvalue; } @@ -292,31 +287,30 @@ lobject_close(lobjectObject *self) RAISES_NEG int lobject_unlink(lobjectObject *self) { - char *error = NULL; int retvalue = -1; Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(self->conn->lock)); - retvalue = pq_begin_locked(self->conn, &error, &_save); + retvalue = pq_begin_locked(self->conn, &_save); if (retvalue < 0) goto end; /* first we make sure the lobject is closed and then we unlink */ - retvalue = lobject_close_locked(self, &error); + retvalue = lobject_close_locked(self); if (retvalue < 0) goto end; retvalue = lo_unlink(self->conn->pgconn, self->oid); if (retvalue < 0) - collect_error(self->conn, &error); + collect_error(self->conn); end: pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return retvalue; } @@ -326,7 +320,6 @@ RAISES_NEG Py_ssize_t lobject_write(lobjectObject *self, const char *buf, size_t len) { Py_ssize_t written; - char *error = NULL; Dprintf("lobject_writing: fd = %d, len = " FORMAT_CODE_SIZE_T, self->fd, len); @@ -336,13 +329,13 @@ lobject_write(lobjectObject *self, const char *buf, size_t len) written = lo_write(self->conn->pgconn, self->fd, buf, len); if (written < 0) - collect_error(self->conn, &error); + collect_error(self->conn); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (written < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return written; } @@ -352,20 +345,19 @@ RAISES_NEG Py_ssize_t lobject_read(lobjectObject *self, char *buf, size_t len) { Py_ssize_t n_read; - char *error = NULL; Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(self->conn->lock)); n_read = lo_read(self->conn->pgconn, self->fd, buf, len); if (n_read < 0) - collect_error(self->conn, &error); + collect_error(self->conn); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (n_read < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return n_read; } @@ -374,7 +366,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) { - char *error = NULL; Py_ssize_t where; Dprintf("lobject_seek: fd = %d, pos = " FORMAT_CODE_PY_SSIZE_T ", whence = %d", @@ -394,13 +385,13 @@ lobject_seek(lobjectObject *self, Py_ssize_t pos, int whence) #endif Dprintf("lobject_seek: where = " FORMAT_CODE_PY_SSIZE_T, where); if (where < 0) - collect_error(self->conn, &error); + collect_error(self->conn); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (where < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return where; } @@ -409,7 +400,6 @@ lobject_seek(lobjectObject *self, Py_ssize_t pos, int whence) RAISES_NEG Py_ssize_t lobject_tell(lobjectObject *self) { - char *error = NULL; Py_ssize_t where; Dprintf("lobject_tell: fd = %d", self->fd); @@ -428,13 +418,13 @@ lobject_tell(lobjectObject *self) #endif Dprintf("lobject_tell: where = " FORMAT_CODE_PY_SSIZE_T, where); if (where < 0) - collect_error(self->conn, &error); + collect_error(self->conn); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (where < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return where; } @@ -443,26 +433,25 @@ lobject_tell(lobjectObject *self) RAISES_NEG int lobject_export(lobjectObject *self, const char *filename) { - char *error = NULL; int retvalue; Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(self->conn->lock)); - retvalue = pq_begin_locked(self->conn, &error, &_save); + retvalue = pq_begin_locked(self->conn, &_save); if (retvalue < 0) goto end; retvalue = lo_export(self->conn->pgconn, self->oid, filename); if (retvalue < 0) - collect_error(self->conn, &error); + collect_error(self->conn); end: pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return retvalue; } @@ -470,7 +459,6 @@ RAISES_NEG int lobject_truncate(lobjectObject *self, size_t len) { int retvalue; - char *error = NULL; Dprintf("lobject_truncate: fd = %d, len = " FORMAT_CODE_SIZE_T, self->fd, len); @@ -489,13 +477,13 @@ lobject_truncate(lobjectObject *self, size_t len) #endif Dprintf("lobject_truncate: result = %d", retvalue); if (retvalue < 0) - collect_error(self->conn, &error); + collect_error(self->conn); pthread_mutex_unlock(&(self->conn->lock)); Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(self->conn, &error); + pq_complete_error(self->conn); return retvalue; } diff --git a/psycopg/pqpath.c b/psycopg/pqpath.c index 062c5425..dc408a1c 100644 --- a/psycopg/pqpath.c +++ b/psycopg/pqpath.c @@ -313,13 +313,12 @@ pq_set_non_blocking(connectionObject *conn, int arg) again the GIL if needed, i.e. if a Python wait callback must be invoked. */ int -pq_execute_command_locked(connectionObject *conn, const char *query, - char **error, PyThreadState **tstate) +pq_execute_command_locked( + connectionObject *conn, const char *query, PyThreadState **tstate) { int pgstatus, retvalue = -1; Dprintf("pq_execute_command_locked: pgconn = %p, query = %s", conn->pgconn, query); - *error = NULL; if (!psyco_green()) { conn_set_result(conn, PQexec(conn->pgconn, query)); @@ -332,9 +331,7 @@ pq_execute_command_locked(connectionObject *conn, const char *query, Dprintf("pq_execute_command_locked: PQexec returned NULL"); PyEval_RestoreThread(*tstate); if (!PyErr_Occurred()) { - const char *msg; - msg = PQerrorMessage(conn->pgconn); - if (msg && *msg) { *error = strdup(msg); } + conn_set_error(conn, PQerrorMessage(conn->pgconn)); } *tstate = PyEval_SaveThread(); goto cleanup; @@ -363,17 +360,17 @@ cleanup: lock. */ RAISES void -pq_complete_error(connectionObject *conn, char **error) +pq_complete_error(connectionObject *conn) { - Dprintf("pq_complete_error: pgconn = %p, pgres = %p, error = %s", - conn->pgconn, conn->pgres, *error ? *error : "(null)"); + Dprintf("pq_complete_error: pgconn = %p, error = %s", + conn->pgconn, conn->error); if (conn->pgres) { pq_raise(conn, NULL, &conn->pgres); /* now conn->pgres is null */ } else { - if (*error != NULL) { - PyErr_SetString(OperationalError, *error); + if (conn->error) { + PyErr_SetString(OperationalError, conn->error); } else if (PyErr_Occurred()) { /* There was a Python error (e.g. in the callback). Don't clobber * it with an unknown exception. (see #410) */ @@ -390,11 +387,7 @@ pq_complete_error(connectionObject *conn, char **error) conn->closed = 2; } } - - if (*error) { - free(*error); - *error = NULL; - } + conn_set_error(conn, NULL); } @@ -407,8 +400,7 @@ pq_complete_error(connectionObject *conn, char **error) relevant result structure. */ int -pq_begin_locked(connectionObject *conn, char **error, - PyThreadState **tstate) +pq_begin_locked(connectionObject *conn, PyThreadState **tstate) { const size_t bufsize = 256; char buf[256]; /* buf size must be same as bufsize */ @@ -439,7 +431,7 @@ pq_begin_locked(connectionObject *conn, char **error, srv_deferrable[conn->deferrable]); } - result = pq_execute_command_locked(conn, buf, error, tstate); + result = pq_execute_command_locked(conn, buf, tstate); if (result == 0) conn->status = CONN_STATUS_BEGIN; @@ -456,7 +448,6 @@ int pq_commit(connectionObject *conn) { int retvalue = -1; - char *error = NULL; Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&conn->lock); @@ -470,7 +461,7 @@ pq_commit(connectionObject *conn) } else { conn->mark += 1; - retvalue = pq_execute_command_locked(conn, "COMMIT", &error, &_save); + retvalue = pq_execute_command_locked(conn, "COMMIT", &_save); } Py_BLOCK_THREADS; @@ -485,14 +476,13 @@ pq_commit(connectionObject *conn) Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(conn, &error); + pq_complete_error(conn); return retvalue; } RAISES_NEG int -pq_abort_locked(connectionObject *conn, char **error, - PyThreadState **tstate) +pq_abort_locked(connectionObject *conn, PyThreadState **tstate) { int retvalue = -1; @@ -505,7 +495,7 @@ pq_abort_locked(connectionObject *conn, char **error, } conn->mark += 1; - retvalue = pq_execute_command_locked(conn, "ROLLBACK", error, tstate); + retvalue = pq_execute_command_locked(conn, "ROLLBACK", tstate); if (retvalue == 0) conn->status = CONN_STATUS_READY; @@ -521,7 +511,6 @@ RAISES_NEG int pq_abort(connectionObject *conn) { int retvalue = -1; - char *error = NULL; Dprintf("pq_abort: pgconn = %p, autocommit = %d, status = %d", conn->pgconn, conn->autocommit, conn->status); @@ -529,7 +518,7 @@ pq_abort(connectionObject *conn) Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&conn->lock); - retvalue = pq_abort_locked(conn, &error, &_save); + retvalue = pq_abort_locked(conn, &_save); Py_BLOCK_THREADS; conn_notice_process(conn); @@ -539,7 +528,7 @@ pq_abort(connectionObject *conn) Py_END_ALLOW_THREADS; if (retvalue < 0) - pq_complete_error(conn, &error); + pq_complete_error(conn); return retvalue; } @@ -554,7 +543,7 @@ pq_abort(connectionObject *conn) */ RAISES_NEG int -pq_reset_locked(connectionObject *conn, char **error, PyThreadState **tstate) +pq_reset_locked(connectionObject *conn, PyThreadState **tstate) { int retvalue = -1; @@ -564,20 +553,20 @@ pq_reset_locked(connectionObject *conn, char **error, PyThreadState **tstate) conn->mark += 1; if (!conn->autocommit && conn->status == CONN_STATUS_BEGIN) { - retvalue = pq_execute_command_locked(conn, "ABORT", error, tstate); + retvalue = pq_execute_command_locked(conn, "ABORT", tstate); if (retvalue != 0) return retvalue; } if (conn->server_version >= 80300) { - retvalue = pq_execute_command_locked(conn, "DISCARD ALL", error, tstate); + retvalue = pq_execute_command_locked(conn, "DISCARD ALL", tstate); if (retvalue != 0) return retvalue; } else { - retvalue = pq_execute_command_locked(conn, "RESET ALL", error, tstate); + retvalue = pq_execute_command_locked(conn, "RESET ALL", tstate); if (retvalue != 0) return retvalue; retvalue = pq_execute_command_locked(conn, - "SET SESSION AUTHORIZATION DEFAULT", error, tstate); + "SET SESSION AUTHORIZATION DEFAULT", tstate); if (retvalue != 0) return retvalue; } @@ -591,7 +580,6 @@ int pq_reset(connectionObject *conn) { int retvalue = -1; - char *error = NULL; Dprintf("pq_reset: pgconn = %p, autocommit = %d, status = %d", conn->pgconn, conn->autocommit, conn->status); @@ -599,7 +587,7 @@ pq_reset(connectionObject *conn) Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&conn->lock); - retvalue = pq_reset_locked(conn, &error, &_save); + retvalue = pq_reset_locked(conn, &_save); Py_BLOCK_THREADS; conn_notice_process(conn); @@ -609,7 +597,7 @@ pq_reset(connectionObject *conn) Py_END_ALLOW_THREADS; if (retvalue < 0) { - pq_complete_error(conn, &error); + pq_complete_error(conn); } else { Py_CLEAR(conn->tpc_xid); @@ -627,9 +615,7 @@ pq_reset(connectionObject *conn) */ char * -pq_get_guc_locked( - connectionObject *conn, const char *param, - char **error, PyThreadState **tstate) +pq_get_guc_locked(connectionObject *conn, const char *param, PyThreadState **tstate) { char query[256]; int size; @@ -639,14 +625,12 @@ pq_get_guc_locked( size = PyOS_snprintf(query, sizeof(query), "SHOW %s", param); if (size < 0 || (size_t)size >= sizeof(query)) { - *error = strdup("SHOW: query too large"); + conn_set_error(conn, "SHOW: query too large"); goto cleanup; } Dprintf("pq_get_guc_locked: pgconn = %p, query = %s", conn->pgconn, query); - *error = NULL; - if (!psyco_green()) { conn_set_result(conn, PQexec(conn->pgconn, query)); } else { @@ -659,9 +643,7 @@ pq_get_guc_locked( Dprintf("pq_get_guc_locked: PQexec returned NULL"); PyEval_RestoreThread(*tstate); if (!PyErr_Occurred()) { - const char *msg; - msg = PQerrorMessage(conn->pgconn); - if (msg && *msg) { *error = strdup(msg); } + conn_set_error(conn, PQerrorMessage(conn->pgconn)); } *tstate = PyEval_SaveThread(); goto cleanup; @@ -688,7 +670,7 @@ cleanup: int pq_set_guc_locked( connectionObject *conn, const char *param, const char *value, - char **error, PyThreadState **tstate) + PyThreadState **tstate) { char query[256]; int size; @@ -705,11 +687,11 @@ pq_set_guc_locked( "SET %s TO '%s'", param, value); } if (size < 0 || (size_t)size >= sizeof(query)) { - *error = strdup("SET: query too large"); + conn_set_error(conn, "SET: query too large"); goto exit; } - rv = pq_execute_command_locked(conn, query, error, tstate); + rv = pq_execute_command_locked(conn, query, tstate); exit: return rv; @@ -721,8 +703,9 @@ exit: * holding the global interpreter lock. */ int -pq_tpc_command_locked(connectionObject *conn, const char *cmd, const char *tid, - char **error, PyThreadState **tstate) +pq_tpc_command_locked( + connectionObject *conn, const char *cmd, const char *tid, + PyThreadState **tstate) { int rv = -1; char *etid = NULL, *buf = NULL; @@ -749,7 +732,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, error, tstate); + rv = pq_execute_command_locked(conn, buf, tstate); PyEval_RestoreThread(*tstate); exit: @@ -885,7 +868,6 @@ pq_flush(connectionObject *conn) RAISES_NEG int _pq_execute_sync(cursorObject *curs, const char *query, int no_result, int no_begin) { - char *error = NULL; connectionObject *conn = curs->conn; CLEARPGRES(curs->pgres); @@ -893,10 +875,10 @@ _pq_execute_sync(cursorObject *curs, const char *query, int no_result, int no_be Py_BEGIN_ALLOW_THREADS; pthread_mutex_lock(&(conn->lock)); - if (!no_begin && pq_begin_locked(conn, &error, &_save) < 0) { + if (!no_begin && pq_begin_locked(conn, &_save) < 0) { pthread_mutex_unlock(&(conn->lock)); Py_BLOCK_THREADS; - pq_complete_error(conn, &error); + pq_complete_error(conn); return -1; } diff --git a/psycopg/pqpath.h b/psycopg/pqpath.h index 7fb007f5..9d732246 100644 --- a/psycopg/pqpath.h +++ b/psycopg/pqpath.h @@ -39,23 +39,20 @@ 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, - char **error, PyThreadState **tstate); +HIDDEN int pq_begin_locked(connectionObject *conn, PyThreadState **tstate); HIDDEN int pq_commit(connectionObject *conn); RAISES_NEG HIDDEN int pq_abort_locked(connectionObject *conn, - char **error, PyThreadState **tstate); + PyThreadState **tstate); RAISES_NEG HIDDEN int pq_abort(connectionObject *conn); -HIDDEN int pq_reset_locked(connectionObject *conn, - char **error, PyThreadState **tstate); +HIDDEN int pq_reset_locked(connectionObject *conn, PyThreadState **tstate); RAISES_NEG HIDDEN int pq_reset(connectionObject *conn); HIDDEN char *pq_get_guc_locked(connectionObject *conn, const char *param, - char **error, PyThreadState **tstate); + PyThreadState **tstate); HIDDEN int pq_set_guc_locked(connectionObject *conn, const char *param, - const char *value, - char **error, PyThreadState **tstate); + const char *value, PyThreadState **tstate); HIDDEN int pq_tpc_command_locked(connectionObject *conn, const char *cmd, const char *tid, - char **error, PyThreadState **tstate); + 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); @@ -63,11 +60,9 @@ RAISES_NEG HIDDEN int pq_set_non_blocking(connectionObject *conn, int arg); HIDDEN void pq_set_critical(connectionObject *conn, const char *msg); -HIDDEN int pq_execute_command_locked(connectionObject *conn, - const char *query, - char **error, +HIDDEN int pq_execute_command_locked(connectionObject *conn, const char *query, PyThreadState **tstate); -RAISES HIDDEN void pq_complete_error(connectionObject *conn, char **error); +RAISES HIDDEN void pq_complete_error(connectionObject *conn); /* replication protocol support */ HIDDEN int pq_copy_both(replicationCursorObject *repl, PyObject *consumer,