psycopg2/lib/extras.py

739 lines
23 KiB
Python
Raw Normal View History

2005-10-18 09:42:00 +04:00
"""Miscellaneous goodies for psycopg2
2005-10-18 09:42:00 +04:00
This module is a generic place used to hold little helper functions
and classes untill a better place in the distribution is found.
"""
# psycopg/extras.py - miscellaneous extra goodies for psycopg
#
# Copyright (C) 2003-2010 Federico Di Gregorio <fog@debian.org>
#
# psycopg2 is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# In addition, as a special exception, the copyright holders give
# permission to link this program with the OpenSSL library (or with
# modified versions of OpenSSL that use the same license as OpenSSL),
# and distribute linked combinations including the two.
#
# You must obey the GNU Lesser General Public License in all respects for
# all of the code used other than OpenSSL.
#
# psycopg2 is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
# License for more details.
import os
import sys
import time
import codecs
import warnings
2009-03-02 12:59:52 +03:00
import re as regex
try:
import logging
except:
logging = None
import psycopg2
from psycopg2 import extensions as _ext
2005-06-24 11:11:44 +04:00
from psycopg2.extensions import cursor as _cursor
2005-07-17 08:08:08 +04:00
from psycopg2.extensions import connection as _connection
2005-06-24 11:11:44 +04:00
from psycopg2.extensions import adapt as _A
from psycopg2.extensions import b
2005-02-27 18:03:53 +03:00
2007-01-16 16:45:41 +03:00
class DictCursorBase(_cursor):
"""Base class for all dict-like cursors."""
def __init__(self, *args, **kwargs):
if 'row_factory' in kwargs:
2007-01-16 16:45:41 +03:00
row_factory = kwargs['row_factory']
del kwargs['row_factory']
else:
raise NotImplementedError(
"DictCursorBase can't be instantiated without a row factory.")
_cursor.__init__(self, *args, **kwargs)
self._query_executed = 0
self._prefetch = 0
2007-01-16 16:45:41 +03:00
self.row_factory = row_factory
def fetchone(self):
if self._prefetch:
res = _cursor.fetchone(self)
2007-01-16 16:45:41 +03:00
if self._query_executed:
self._build_index()
if not self._prefetch:
res = _cursor.fetchone(self)
2009-03-02 12:59:52 +03:00
return res
2007-01-16 16:45:41 +03:00
def fetchmany(self, size=None):
if self._prefetch:
res = _cursor.fetchmany(self, size)
2007-01-16 16:45:41 +03:00
if self._query_executed:
self._build_index()
if not self._prefetch:
res = _cursor.fetchmany(self, size)
2009-03-02 12:59:52 +03:00
return res
2007-01-16 16:45:41 +03:00
def fetchall(self):
if self._prefetch:
res = _cursor.fetchall(self)
2007-01-16 16:45:41 +03:00
if self._query_executed:
self._build_index()
if not self._prefetch:
res = _cursor.fetchall(self)
2009-03-02 12:59:52 +03:00
return res
2007-01-16 16:45:41 +03:00
def next(self):
if self._prefetch:
res = _cursor.fetchone(self)
if res is None:
raise StopIteration()
2009-03-02 12:59:52 +03:00
if self._query_executed:
self._build_index()
if not self._prefetch:
res = _cursor.fetchone(self)
if res is None:
raise StopIteration()
2007-01-16 16:45:41 +03:00
return res
2005-07-17 08:08:08 +04:00
class DictConnection(_connection):
"""A connection that uses `DictCursor` automatically."""
def cursor(self, name=None):
if name is None:
return _connection.cursor(self, cursor_factory=DictCursor)
else:
2009-03-02 12:59:52 +03:00
return _connection.cursor(self, name, cursor_factory=DictCursor)
2007-01-16 16:45:41 +03:00
class DictCursor(DictCursorBase):
"""A cursor that keeps a list of column name -> index mappings."""
2007-01-16 16:45:41 +03:00
def __init__(self, *args, **kwargs):
kwargs['row_factory'] = DictRow
DictCursorBase.__init__(self, *args, **kwargs)
self._prefetch = 1
2007-01-16 16:45:41 +03:00
def execute(self, query, vars=None):
self.index = {}
2007-01-16 16:45:41 +03:00
self._query_executed = 1
return _cursor.execute(self, query, vars)
2005-12-06 08:55:58 +03:00
def callproc(self, procname, vars=None):
self.index = {}
2007-01-16 16:45:41 +03:00
self._query_executed = 1
return _cursor.callproc(self, procname, vars)
def _build_index(self):
2007-01-16 16:45:41 +03:00
if self._query_executed == 1 and self.description:
for i in range(len(self.description)):
self.index[self.description[i][0]] = i
self._query_executed = 0
2005-03-01 19:41:02 +03:00
class DictRow(list):
2010-02-15 20:41:30 +03:00
"""A row object that allow by-colmun-name access to data."""
2009-05-09 12:19:15 +04:00
__slots__ = ('_index',)
def __init__(self, cursor):
2005-05-10 06:29:24 +04:00
self._index = cursor.index
self[:] = [None] * len(cursor.description)
def __getitem__(self, x):
if not isinstance(x, (int, slice)):
2005-05-10 06:29:24 +04:00
x = self._index[x]
return list.__getitem__(self, x)
2005-02-27 18:03:53 +03:00
def __setitem__(self, x, v):
if not isinstance(x, (int, slice)):
x = self._index[x]
list.__setitem__(self, x, v)
2005-04-11 11:20:46 +04:00
def items(self):
return list(self.iteritems())
2005-04-25 08:58:38 +04:00
def keys(self):
2006-01-06 05:58:24 +03:00
return self._index.keys()
2005-04-25 08:58:38 +04:00
2005-05-19 08:48:26 +04:00
def values(self):
return tuple(self[:])
def has_key(self, x):
return x in self._index
2006-01-06 05:58:24 +03:00
2005-05-19 08:48:26 +04:00
def get(self, x, default=None):
try:
return self[x]
except:
return default
2006-10-06 09:22:54 +04:00
def iteritems(self):
for n, v in self._index.iteritems():
2006-10-06 09:22:54 +04:00
yield n, list.__getitem__(self, v)
2005-02-27 18:03:53 +03:00
2009-04-19 18:25:12 +04:00
def iterkeys(self):
return self._index.iterkeys()
def itervalues(self):
return list.__iter__(self)
def copy(self):
return dict(self.iteritems())
2009-04-19 18:25:12 +04:00
def __contains__(self, x):
return x in self._index
# grop the crusty Py2 methods
if sys.version_info[0] > 2:
items = iteritems; del iteritems
keys = iterkeys; del iterkeys
values = itervalues; del itervalues
del has_key
2007-01-16 16:45:41 +03:00
class RealDictConnection(_connection):
"""A connection that uses `RealDictCursor` automatically."""
def cursor(self, name=None):
if name is None:
return _connection.cursor(self, cursor_factory=RealDictCursor)
else:
2009-02-23 23:39:25 +03:00
return _connection.cursor(self, name, cursor_factory=RealDictCursor)
2007-01-16 16:45:41 +03:00
class RealDictCursor(DictCursorBase):
"""A cursor that uses a real dict as the base type for rows.
Note that this cursor is extremely specialized and does not allow
the normal access (using integer indices) to fetched data. If you need
to access database rows both as a dictionary and a list, then use
the generic `DictCursor` instead of `!RealDictCursor`.
2007-01-16 16:45:41 +03:00
"""
def __init__(self, *args, **kwargs):
kwargs['row_factory'] = RealDictRow
DictCursorBase.__init__(self, *args, **kwargs)
self._prefetch = 0
2007-01-16 16:45:41 +03:00
def execute(self, query, vars=None):
2007-01-16 16:45:41 +03:00
self.column_mapping = []
self._query_executed = 1
return _cursor.execute(self, query, vars)
2007-01-16 16:45:41 +03:00
def callproc(self, procname, vars=None):
self.column_mapping = []
self._query_executed = 1
return _cursor.callproc(self, procname, vars)
2007-01-16 16:45:41 +03:00
def _build_index(self):
if self._query_executed == 1 and self.description:
for i in range(len(self.description)):
self.column_mapping.append(self.description[i][0])
self._query_executed = 0
2007-01-16 16:45:41 +03:00
class RealDictRow(dict):
"""A ``dict`` subclass representing a data record."""
2009-05-09 12:19:15 +04:00
__slots__ = ('_column_mapping')
2009-05-09 12:19:15 +04:00
2007-01-16 16:45:41 +03:00
def __init__(self, cursor):
dict.__init__(self)
self._column_mapping = cursor.column_mapping
def __setitem__(self, name, value):
if type(name) == int:
2007-01-16 16:45:41 +03:00
name = self._column_mapping[name]
return dict.__setitem__(self, name, value)
2010-11-06 04:39:43 +03:00
class NamedTupleConnection(_connection):
"""A connection that uses `NamedTupleCursor` automatically."""
def cursor(self, *args, **kwargs):
kwargs['cursor_factory'] = NamedTupleCursor
return _connection.cursor(self, *args, **kwargs)
class NamedTupleCursor(_cursor):
"""A cursor that generates results as |namedtuple|__.
`!fetch*()` methods will return named tuples instead of regular tuples, so
their elements can be accessed both as regular numeric items as well as
attributes.
>>> nt_cur = conn.cursor(cursor_factory=psycopg2.extras.NamedTupleCursor)
>>> rec = nt_cur.fetchone()
>>> rec
Record(id=1, num=100, data="abc'def")
>>> rec[1]
100
>>> rec.data
"abc'def"
.. |namedtuple| replace:: `!namedtuple`
.. __: http://docs.python.org/release/2.6/library/collections.html#collections.namedtuple
"""
Record = None
def execute(self, query, vars=None):
self.Record = None
return _cursor.execute(self, query, vars)
def executemany(self, query, vars):
self.Record = None
return _cursor.executemany(self, vars)
def callproc(self, procname, vars=None):
self.Record = None
return _cursor.callproc(self, procname, vars)
2010-11-06 04:39:43 +03:00
def fetchone(self):
t = _cursor.fetchone(self)
if t is not None:
nt = self.Record
if nt is None:
nt = self.Record = self._make_nt()
2010-11-06 04:39:43 +03:00
return nt(*t)
def fetchmany(self, size=None):
nt = self.Record
if nt is None:
nt = self.Record = self._make_nt()
2010-11-06 04:39:43 +03:00
ts = _cursor.fetchmany(self, size)
return [nt(*t) for t in ts]
def fetchall(self):
nt = self.Record
if nt is None:
nt = self.Record = self._make_nt()
2010-11-06 04:39:43 +03:00
ts = _cursor.fetchall(self)
return [nt(*t) for t in ts]
def __iter__(self):
return iter(self.fetchall())
try:
from collections import namedtuple
except ImportError, _exc:
def _make_nt(self):
raise self._exc
else:
def _make_nt(self, namedtuple=namedtuple):
return namedtuple("Record", [d[0] for d in self.description or ()])
2010-11-06 04:39:43 +03:00
class LoggingConnection(_connection):
"""A connection that logs all queries to a file or logger__ object.
.. __: http://docs.python.org/library/logging.html
"""
def initialize(self, logobj):
"""Initialize the connection to log to ``logobj``.
The ``logobj`` parameter can be an open file object or a Logger
instance from the standard logging module.
"""
self._logobj = logobj
if logging and isinstance(logobj, logging.Logger):
self.log = self._logtologger
else:
self.log = self._logtofile
def filter(self, msg, curs):
"""Filter the query before logging it.
This is the method to overwrite to filter unwanted queries out of the
log or to add some extra data to the output. The default implementation
just does nothing.
"""
return msg
def _logtofile(self, msg, curs):
msg = self.filter(msg, curs)
if msg: self._logobj.write(msg + os.linesep)
def _logtologger(self, msg, curs):
msg = self.filter(msg, curs)
if msg: self._logobj.debug(msg)
def _check(self):
if not hasattr(self, '_logobj'):
raise self.ProgrammingError(
"LoggingConnection object has not been initialize()d")
def cursor(self, name=None):
self._check()
2009-02-23 23:39:25 +03:00
if name is None:
return _connection.cursor(self, cursor_factory=LoggingCursor)
else:
2009-02-23 23:39:25 +03:00
return _connection.cursor(self, name, cursor_factory=LoggingCursor)
class LoggingCursor(_cursor):
"""A cursor that logs queries using its connection logging facilities."""
def execute(self, query, vars=None):
try:
return _cursor.execute(self, query, vars)
finally:
self.connection.log(self.query, self)
def callproc(self, procname, vars=None):
try:
return _cursor.callproc(self, procname, vars)
finally:
self.connection.log(self.query, self)
class MinTimeLoggingConnection(LoggingConnection):
"""A connection that logs queries based on execution time.
This is just an example of how to sub-class `LoggingConnection` to
provide some extra filtering for the logged queries. Both the
`inizialize()` and `filter()` methods are overwritten to make sure
that only queries executing for more than ``mintime`` ms are logged.
Note that this connection uses the specialized cursor
`MinTimeLoggingCursor`.
"""
def initialize(self, logobj, mintime=0):
LoggingConnection.initialize(self, logobj)
self._mintime = mintime
def filter(self, msg, curs):
t = (time.time() - curs.timestamp) * 1000
if t > self._mintime:
return msg + os.linesep + " (execution time: %d ms)" % t
def cursor(self, name=None):
self._check()
2009-02-23 23:39:25 +03:00
if name is None:
return _connection.cursor(self, cursor_factory=MinTimeLoggingCursor)
else:
2009-02-23 23:39:25 +03:00
return _connection.cursor(self, name, cursor_factory=MinTimeLoggingCursor)
class MinTimeLoggingCursor(LoggingCursor):
"""The cursor sub-class companion to `MinTimeLoggingConnection`."""
def execute(self, query, vars=None):
self.timestamp = time.time()
return LoggingCursor.execute(self, query, vars)
def callproc(self, procname, vars=None):
self.timestamp = time.time()
return LoggingCursor.execute(self, procname, vars)
# a dbtype and adapter for Python UUID type
try:
import uuid
class UUID_adapter(object):
"""Adapt Python's uuid.UUID__ type to PostgreSQL's uuid__.
.. __: http://docs.python.org/library/uuid.html
.. __: http://www.postgresql.org/docs/8.4/static/datatype-uuid.html
"""
def __init__(self, uuid):
self._uuid = uuid
def prepare(self, conn):
pass
def getquoted(self):
return "'"+str(self._uuid)+"'::uuid"
__str__ = getquoted
2009-10-04 14:34:02 +04:00
def register_uuid(oids=None, conn_or_curs=None):
"""Create the UUID type and an uuid.UUID adapter."""
2009-10-04 14:34:02 +04:00
if not oids:
oid1 = 2950
oid2 = 2951
elif type(oids) == list:
oid1, oid2 = oids
else:
oid1 = oids
oid2 = 2951
def parseUUIDARRAY(data, cursor):
if data is None:
return None
elif data == '{}':
return []
else:
return [((len(x) > 0 and x != 'NULL') and uuid.UUID(x) or None)
for x in data[1:-1].split(',')]
_ext.UUID = _ext.new_type((oid1, ), "UUID",
2008-09-24 03:27:52 +04:00
lambda data, cursor: data and uuid.UUID(data) or None)
2009-10-04 14:34:02 +04:00
_ext.UUIDARRAY = _ext.new_type((oid2,), "UUID[]", parseUUIDARRAY)
2009-03-02 12:59:52 +03:00
_ext.register_type(_ext.UUID, conn_or_curs)
2009-10-04 14:34:02 +04:00
_ext.register_type(_ext.UUIDARRAY, conn_or_curs)
_ext.register_adapter(uuid.UUID, UUID_adapter)
2009-10-04 14:34:02 +04:00
return _ext.UUID
2008-09-24 03:27:52 +04:00
except ImportError, e:
def register_uuid(oid=None):
"""Create the UUID type and an uuid.UUID adapter.
This is a fake function that will always raise an error because the
import of the uuid module failed.
"""
raise e
2008-09-24 03:27:52 +04:00
# a type, dbtype and adapter for PostgreSQL inet type
class Inet(object):
"""Wrap a string to allow for correct SQL-quoting of inet values.
Note that this adapter does NOT check the passed value to make
sure it really is an inet-compatible address but DOES call adapt()
on it to make sure it is impossible to execute an SQL-injection
by passing an evil value to the initializer.
"""
def __init__(self, addr):
2010-02-13 05:14:38 +03:00
self.addr = addr
2008-09-24 03:27:52 +04:00
2010-02-14 23:14:17 +03:00
def __repr__(self):
return "%s(%r)" % (self.__class__.__name__, self.addr)
2008-09-24 03:27:52 +04:00
def prepare(self, conn):
self._conn = conn
def getquoted(self):
2010-02-14 23:14:17 +03:00
obj = _A(self.addr)
2008-09-24 03:27:52 +04:00
if hasattr(obj, 'prepare'):
obj.prepare(self._conn)
2010-12-29 05:46:36 +03:00
return obj.getquoted() + b("::inet")
2008-09-24 03:27:52 +04:00
def __conform__(self, foo):
if foo is _ext.ISQLQuote:
return self
2008-09-24 03:27:52 +04:00
def __str__(self):
return str(self.addr)
2009-03-02 12:59:52 +03:00
def register_inet(oid=None, conn_or_curs=None):
2008-09-24 03:27:52 +04:00
"""Create the INET type and an Inet adapter."""
if not oid: oid = 869
_ext.INET = _ext.new_type((oid, ), "INET",
lambda data, cursor: data and Inet(data) or None)
2009-03-02 12:59:52 +03:00
_ext.register_type(_ext.INET, conn_or_curs)
2008-09-24 03:27:52 +04:00
return _ext.INET
def register_tstz_w_secs(oids=None, conn_or_curs=None):
"""The function used to register an alternate type caster for
:sql:`TIMESTAMP WITH TIME ZONE` to deal with historical time zones with
seconds in the UTC offset.
These are now correctly handled by the default type caster, so currently
the function doesn't do anything.
"""
warnings.warn("deprecated", DeprecationWarning)
import select
from psycopg2.extensions import POLL_OK, POLL_READ, POLL_WRITE
from psycopg2 import OperationalError
def wait_select(conn):
"""Wait until a connection or cursor has data available.
The function is an example of a wait callback to be registered with
`~psycopg2.extensions.set_wait_callback()`. This function uses `!select()`
to wait for data available.
"""
while 1:
state = conn.poll()
if state == POLL_OK:
break
elif state == POLL_READ:
select.select([conn.fileno()], [], [])
elif state == POLL_WRITE:
select.select([], [conn.fileno()], [])
else:
raise OperationalError("bad state from poll: %s" % state)
class HstoreAdapter(object):
"""Adapt a Python dict to the hstore syntax."""
def __init__(self, wrapped):
self.wrapped = wrapped
def prepare(self, conn):
self.conn = conn
# use an old-style getquoted implementation if required
if conn.server_version < 90000:
self.getquoted = self._getquoted_8
def _getquoted_8(self):
"""Use the operators available in PG pre-9.0."""
if not self.wrapped:
return b("''::hstore")
adapt = _ext.adapt
rv = []
for k, v in self.wrapped.iteritems():
k = adapt(k)
k.prepare(self.conn)
k = k.getquoted()
if v is not None:
v = adapt(v)
v.prepare(self.conn)
v = v.getquoted()
else:
v = b('NULL')
# XXX this b'ing is painfully inefficient!
rv.append(b("(") + k + b(" => ") + v + b(")"))
return b("(") + b('||').join(rv) + b(")")
def _getquoted_9(self):
"""Use the hstore(text[], text[]) function."""
if not self.wrapped:
return b("''::hstore")
k = _ext.adapt(self.wrapped.keys())
k.prepare(self.conn)
v = _ext.adapt(self.wrapped.values())
v.prepare(self.conn)
return b("hstore(") + k.getquoted() + b(", ") + v.getquoted() + b(")")
getquoted = _getquoted_9
_re_hstore = regex.compile(r"""
# hstore key:
# a string of normal or escaped chars
"((?: [^"\\] | \\. )*)"
\s*=>\s* # hstore value
(?:
NULL # the value can be null - not catched
# or a quoted string like the key
| "((?: [^"\\] | \\. )*)"
)
(?:\s*,\s*|$) # pairs separated by comma or end of string.
""", regex.VERBOSE)
@classmethod
def parse(self, s, cur, _bsdec=regex.compile(r"\\(.)")):
"""Parse an hstore representation in a Python string.
The hstore is represented as something like::
"a"=>"1", "b"=>"2"
with backslash-escaped strings.
"""
if s is None:
return None
rv = {}
start = 0
for m in self._re_hstore.finditer(s):
if m is None or m.start() != start:
raise psycopg2.InterfaceError(
"error parsing hstore pair at char %d" % start)
k = _bsdec.sub(r'\1', m.group(1))
v = m.group(2)
if v is not None:
v = _bsdec.sub(r'\1', v)
rv[k] = v
start = m.end()
if start < len(s):
raise psycopg2.InterfaceError(
"error parsing hstore: unparsed data after char %d" % start)
return rv
@classmethod
def parse_unicode(self, s, cur):
"""Parse an hstore returning unicode keys and values."""
if s is None:
return None
s = s.decode(_ext.encodings[cur.connection.encoding])
return self.parse(s, cur)
@classmethod
def get_oids(self, conn_or_curs):
"""Return the oid of the hstore and hstore[] types.
Return None if hstore is not available.
"""
if hasattr(conn_or_curs, 'execute'):
conn = conn_or_curs.connection
curs = conn_or_curs
else:
conn = conn_or_curs
curs = conn_or_curs.cursor()
2010-09-27 01:11:06 +04:00
# Store the transaction status of the connection to revert it after use
conn_status = conn.status
2010-09-27 01:11:06 +04:00
# column typarray not available before PG 8.3
typarray = conn.server_version >= 80300 and "typarray" or "NULL"
# get the oid for the hstore
curs.execute("""\
SELECT t.oid, %s
2010-09-27 01:11:06 +04:00
FROM pg_type t JOIN pg_namespace ns
ON typnamespace = ns.oid
WHERE typname = 'hstore' and nspname = 'public';
""" % typarray)
oids = curs.fetchone()
2010-09-27 01:11:06 +04:00
# revert the status of the connection as before the command
if (conn_status != _ext.STATUS_IN_TRANSACTION
and conn.isolation_level != _ext.ISOLATION_LEVEL_AUTOCOMMIT):
conn.rollback()
2010-09-27 01:11:06 +04:00
return oids
def register_hstore(conn_or_curs, globally=False, unicode=False):
2010-09-28 03:33:34 +04:00
"""Register adapter and typecaster for `dict`\-\ |hstore| conversions.
The function must receive a connection or cursor as the |hstore| oid is
different in each database. The typecaster will normally be registered
only on the connection or cursor passed as argument. If your application
uses a single database you can pass *globally*\=True to have the typecaster
registered on all the connections.
On Python 2, by default the returned dicts will have `str` objects as keys and values:
2010-09-28 03:33:34 +04:00
use *unicode*\=True to return `unicode` objects instead. When adapting a
dictionary both `str` and `unicode` keys and values are handled (the
`unicode` values will be converted according to the current
`~connection.encoding`). The option is not available on Python 3.
2010-09-28 03:33:34 +04:00
The |hstore| contrib module must be already installed in the database
(executing the ``hstore.sql`` script in your ``contrib`` directory).
Raise `~psycopg2.ProgrammingError` if the type is not found.
"""
oids = HstoreAdapter.get_oids(conn_or_curs)
2010-09-27 01:11:06 +04:00
if oids is None:
raise psycopg2.ProgrammingError(
"hstore type not found in the database. "
"please install it from your 'contrib/hstore.sql' file")
# create and register the typecaster
if sys.version_info[0] < 3 and unicode:
cast = HstoreAdapter.parse_unicode
else:
cast = HstoreAdapter.parse
HSTORE = _ext.new_type((oids[0],), "HSTORE", cast)
_ext.register_type(HSTORE, not globally and conn_or_curs or None)
2010-09-27 01:11:06 +04:00
_ext.register_adapter(dict, HstoreAdapter)
__all__ = filter(lambda k: not k.startswith('_'), locals().keys())