/* Replacement for PQexec using the user-provided wait function.
*
* The function should be called helding the connection lock, and
* the GIL because some Python code is expected to be called.
*
* If PGresult is NULL, there may have been either a libpq error
* or an exception raised by Python code: before raising an exception
* check if there is already one using `PyErr_Occurred()` */
PGresult *
psyco_exec_green(connectionObject *conn, const char *command)
{
PGresult *result = NULL;
/* Send the query asynchronously */
if (0 == pq_send_query(conn, command)) {
goto end;
}
/* Enter the poll loop with a write. When writing is finished the poll
implementation will set the status to ASYNC_READ without exiting the
loop. If read is finished the status is finally set to ASYNC_DONE.
*/
conn->async_status = ASYNC_WRITE;
if (0 != psyco_wait(conn)) {
psyco_clear_result_blocking(conn);
goto end;
}
/* Now we can read the data without fear of blocking. */
result = pq_get_last_result(conn);
end:
conn->async_status = ASYNC_DONE;
return result;
}
/* Replacement for PQexec using the user-provided wait function.
*
* The function should be called helding the connection lock, and
* the GIL because some Python code is expected to be called.
*
* If PGresult is NULL, there may have been either a libpq error
* or an exception raised by Python code: before raising an exception
* check if there is already one using `PyErr_Occurred()` */
PGresult *
psyco_exec_green(connectionObject *conn, const char *command)
{
PGresult *result = NULL;
/* Check that there is a single concurrently executing query */
if (conn->async_cursor) {
PyErr_SetString(ProgrammingError,
"a single async query can be executed on the same connection");
goto end;
}
/* we don't care about which cursor is executing the query, and
* it may also be that no cursor is involved at all and this is
* an internal query. So just store anything in the async_cursor,
* respecting the code expecting it to be a weakref */
if (!(conn->async_cursor = PyWeakref_NewRef((PyObject*)conn, NULL))) {
goto end;
}
/* Send the query asynchronously */
if (0 == pq_send_query(conn, command)) {
goto end;
}
/* Enter the poll loop with a write. When writing is finished the poll
implementation will set the status to ASYNC_READ without exiting the
loop. If read is finished the status is finally set to ASYNC_DONE.
*/
conn->async_status = ASYNC_WRITE;
if (0 != psyco_wait(conn)) {
psyco_clear_result_blocking(conn);
goto end;
}
/* Now we can read the data without fear of blocking. */
result = pq_get_last_result(conn);
end:
conn->async_status = ASYNC_DONE;
Py_CLEAR(conn->async_cursor);
return result;
}
/* Advance to the next state during an async connection setup
*
* If the connection is green, this is performed by the regular
* sync code so the queries are sent by conn_setup() while in
* CONN_STATUS_READY state.
*/
static int
_conn_poll_setup_async(connectionObject *self)
{
int res = PSYCO_POLL_ERROR;
switch (self->status) {
case CONN_STATUS_CONNECTING:
self->equote = conn_get_standard_conforming_strings(self->pgconn);
self->protocol = conn_get_protocol_version(self->pgconn);
self->server_version = conn_get_server_version(self->pgconn);
if (3 != self->protocol) {
PyErr_SetString(InterfaceError, "only protocol 3 supported");
break;
}
if (0 > conn_read_encoding(self, self->pgconn)) {
break;
}
if (0 > conn_setup_cancel(self, self->pgconn)) {
return -1;
}
/* asynchronous connections always use isolation level 0, the user is
* expected to manage the transactions himself, by sending
* (asynchronously) BEGIN and COMMIT statements.
*/
self->autocommit = 1;
/* If the datestyle is ISO or anything else good,
* we can skip the CONN_STATUS_DATESTYLE step.
* Note that we cannot change the datestyle on a replication
* connection.
*/
if (!dsn_has_replication(self->dsn) && !conn_is_datestyle_ok(self->pgconn)) {
Dprintf("conn_poll: status -> CONN_STATUS_DATESTYLE");
self->status = CONN_STATUS_DATESTYLE;
if (0 == pq_send_query(self, psyco_datestyle)) {
PyErr_SetString(OperationalError, PQerrorMessage(self->pgconn));
break;
}
Dprintf("conn_poll: async_status -> ASYNC_WRITE");
self->async_status = ASYNC_WRITE;
res = PSYCO_POLL_WRITE;
}
else {
Dprintf("conn_poll: status -> CONN_STATUS_READY");
self->status = CONN_STATUS_READY;
res = PSYCO_POLL_OK;
}
break;
case CONN_STATUS_DATESTYLE:
res = _conn_poll_query(self);
if (res == PSYCO_POLL_OK) {
res = PSYCO_POLL_ERROR;
if (self->pgres == NULL
|| PQresultStatus(self->pgres) != PGRES_COMMAND_OK ) {
PyErr_SetString(OperationalError, "can't set datestyle to ISO");
break;
}
CLEARPGRES(self->pgres);
Dprintf("conn_poll: status -> CONN_STATUS_READY");
self->status = CONN_STATUS_READY;
res = PSYCO_POLL_OK;
}
break;
}
return res;
}
