def poll(self):
if self.status == consts.STATUS_SETUP:
self.status = consts.STATUS_CONNECTING
return consts.POLL_WRITE
if self.status == consts.STATUS_CONNECTING:
res = self._poll_connecting()
if res == consts.POLL_OK and self._async:
return self._poll_setup_async()
return res
if self.status in (consts.STATUS_READY, consts.STATUS_BEGIN,
consts.STATUS_PREPARED):
res = self._poll_query()
if res == consts.POLL_OK and self._async and self._async_cursor:
# Get the cursor object from the weakref
curs = self._async_cursor()
if curs is None:
util.pq_clear_async(self._pgconn)
raise exceptions.InterfaceError(
"the asynchronous cursor has disappeared")
libpq.PQclear(curs._pgres)
curs._pgres = util.pq_get_last_result(self._pgconn)
try:
curs._pq_fetch()
finally:
self._async_cursor = None
return res
return consts.POLL_ERROR
def pq_clear_async(conn):
pgconn = conn._pgconn
while True:
pgres = libpq.PQgetResult(pgconn)
if not pgres:
break
if libpq.PQresultStatus(pgres) == libpq.PGRES_FATAL_ERROR:
raise conn._create_exception()
libpq.PQclear(pgres)
def _get_guc(self, name):
"""Return the value of a configuration parameter."""
with self._lock:
query = 'SHOW %s' % name
if _green_callback:
pgres = self._execute_green(query)
else:
pgres = libpq.PQexec(self._pgconn, query)
if not pgres or libpq.PQresultStatus(pgres) != libpq.PGRES_TUPLES_OK:
raise exceptions.OperationalError("can't fetch %s" % name)
rv = ffi.string(libpq.PQgetvalue(pgres, 0, 0))
libpq.PQclear(pgres)
return rv
def pq_get_last_result(pgconn):
pgres_next = None
pgres = libpq.PQgetResult(pgconn)
if not pgres:
return
while True:
pgres_next = libpq.PQgetResult(pgconn)
if not pgres_next:
break
if pgres:
libpq.PQclear(pgres)
pgres = pgres_next
return pgres
def _poll_setup_async(self):
"""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.
"""
if self.status == consts.STATUS_CONNECTING:
util.pq_set_non_blocking(self._pgconn, 1, True)
self._equote = self._get_equote()
self._get_encoding()
self._have_cancel_key()
self._autocommit = True
# If the current datestyle is not compatible (not ISO) then
# force it to ISO
if not self._iso_compatible_datestyle():
self.status = consts.STATUS_DATESTYLE
if libpq.PQsendQuery(self._pgconn, b"SET DATESTYLE TO 'ISO'"):
self._async_status = consts.ASYNC_WRITE
return consts.POLL_WRITE
else:
raise self._create_exception()
self.status = consts.STATUS_READY
return consts.POLL_OK
if self.status == consts.STATUS_DATESTYLE:
res = self._poll_query()
if res != consts.POLL_OK:
return res
pgres = util.pq_get_last_result(self._pgconn)
if not pgres or \
libpq.PQresultStatus(pgres) != libpq.PGRES_COMMAND_OK:
raise exceptions.OperationalError("can't set datetyle to ISO")
libpq.PQclear(pgres)
self.status = consts.STATUS_READY
return consts.POLL_OK
return consts.POLL_ERROR
def _execute_command(self, command):
with self._lock:
if _green_callback:
pgres = self._execute_green(command)
else:
pgres = libpq.PQexec(self._pgconn, ascii_to_bytes(command))
if not pgres:
raise self._create_exception()
try:
pgstatus = libpq.PQresultStatus(pgres)
if pgstatus != libpq.PGRES_COMMAND_OK:
exc = self._create_exception(pgres=pgres)
pgres = None # ownership transferred to exc
raise exc
finally:
if pgres:
libpq.PQclear(pgres)
def __del__(self):
if self._pgres:
libpq.PQclear(self._pgres)
self._pgres = None
def pq_clear_async(pgconn):
while True:
pgres = libpq.PQgetResult(pgconn)
if not pgres:
break
libpq.PQclear(pgres)
def _clear_pgres(self):
if self._pgres:
libpq.PQclear(self._pgres)
self._pgres = ffi.NULL
def __del__(self):
if self._pgres:
libpq.PQclear(self._pgres)
self._pgres = ffi.NULL
