psycopg2.extensions – Extensions to the DB API — Psycopg 2.5.2 documentation

### Navigation

- index
- modules |
- next |
- previous |
- Psycopg 2.5.2 documentation »

# `psycopg2.extensions` – Extensions to the DB API

The module contains a few objects and function extending the minimum set of functionalities defined by the DB API 2.0.

class `psycopg2.extensions.` `connection`(dsn, async=False)

  Is the class usually returned by the `connect()` function. It is exposed by the `extensions` module in order to allow subclassing to extend its behaviour: the subclass should be passed to the `connect()` function using the `connection_factory` parameter. See also Connection and cursor factories.

  For a complete description of the class, see `connection`.

class `psycopg2.extensions.` `cursor`(conn, name=None)

  It is the class usually returned by the `connection.cursor()` method. It is exposed by the `extensions` module in order to allow subclassing to extend its behaviour: the subclass should be passed to the `cursor()` method using the `cursor_factory` parameter. See also Connection and cursor factories.

  For a complete description of the class, see `cursor`.

class `psycopg2.extensions.` `lobject`(conn[, oid[, mode[, new_oid[, new_file]]]])

  Wrapper for a PostgreSQL large object. See Access to PostgreSQL large objects for an overview.

  The class can be subclassed: see the `connection.lobject()` to know how to specify a `lobject` subclass.

  New in version 2.0.8.

  `oid`

    Database OID of the object.

  `mode`

    The mode the database was open. See `connection.lobject()` for a description of the available modes.

  `read`(bytes=-1)

    Read a chunk of data from the current file position. If -1 (default) read all the remaining data.

    The result is an Unicode string (decoded according to `connection.encoding`) if the file was open in `t` mode, a bytes string for `b` mode.

    Changed in version 2.4: added Unicode support.

  `write`(str)

    Write a string to the large object. Return the number of bytes written. Unicode strings are encoded in the `connection.encoding` before writing.

    Changed in version 2.4: added Unicode support.

  `export`(file_name)

    Export the large object content to the file system.

    The method uses the efficient `lo_export()` libpq function.

  `seek`(offset, whence=0)

    Set the lobject current position.

  `tell`()

    Return the lobject current position.

  `truncate`(len=0)

    New in version 2.2.0.

    Truncate the lobject to the given size.

    The method will only be available if Psycopg has been built against libpq from PostgreSQL 8.3 or later and can only be used with PostgreSQL servers running these versions. It uses the `lo_truncate()` libpq function.

    Warning

    If Psycopg is built with `lo_truncate()` support (i.e. if the pg_config used during setup is version >= 8.3), but at runtime an older libpq is found, Psycopg will fail to import. See the lo_truncate FAQ about the problem.

  `close`()

    Close the object.

  `closed`

    Boolean attribute specifying if the object is closed.

  `unlink`()

    Close the object and remove it from the database.

class `psycopg2.extensions.` `Notify`(pid, channel, payload='')

  A notification received from the backend.

  `Notify` instances are made available upon reception on the `notifies` member of the listening connection. The object can be also accessed as a 2 items tuple returning the members `(pid,channel)` for backward compatibility.

  See Asynchronous notifications for details.

  New in version 2.3.

  `channel`

    The name of the channel to which the notification was sent.

  `payload`

    The payload message of the notification.

    Attaching a payload to a notification is only available since PostgreSQL 9.0: for notifications received from previous versions of the server this member is always the empty string.

  `pid`

    The ID of the backend process that sent the notification.

    Note: if the sending session was handled by Psycopg, you can use `get_backend_pid()` to know its PID.

class `psycopg2.extensions.` `Xid`(format_id, gtrid, bqual)

  A transaction identifier used for two-phase commit.

  Usually returned by the connection methods `xid()` and `tpc_recover()`. `Xid` instances can be unpacked as a 3-item tuples containing the items `(format_id,gtrid,bqual)`. The `str()` of the object returns the transaction ID used in the commands sent to the server.

  See Two-Phase Commit protocol support for an introduction.

  New in version 2.3.

  `from_string`(s)

    Create a `Xid` object from a string representation. Static method.

    If s is a PostgreSQL transaction ID produced by a XA transaction, the returned object will have `format_id`, `gtrid`, `bqual` set to the values of the preparing XA id. Otherwise only the `gtrid` is populated with the unparsed string. The operation is the inverse of the one performed by `str(xid)`.

  `bqual`

    Branch qualifier of the transaction.

    In a XA transaction every resource participating to a transaction receives a distinct branch qualifier. `None` if the transaction doesn’t follow the XA standard.

  `database`

    Database the recovered transaction belongs to.

  `format_id`

    Format ID in a XA transaction.

    A non-negative 32 bit integer. `None` if the transaction doesn’t follow the XA standard.

  `gtrid`

    Global transaction ID in a XA transaction.

    If the transaction doesn’t follow the XA standard, it is the plain transaction ID used in the server commands.

  `owner`

    Name of the user who prepared a recovered transaction.

  `prepared`

    Timestamp (with timezone) in which a recovered transaction was prepared.

class `psycopg2.extensions.` `Diagnostics`(exception)

  Details from a database error report.

  The object is returned by the `diag` attribute of the `Error` object. All the information available from the `PQresultErrorField()` function are exposed as attributes by the object, e.g. the `severity` attribute returns the `PG_DIAG_SEVERITY` code. Please refer to the PostgreSQL documentation for the meaning of all the attributes.

  New in version 2.5.

  The attributes currently available are:

  `column_name`
  `constraint_name`
  `context`
  `datatype_name`
  `internal_position`
  `internal_query`
  `message_detail`
  `message_hint`
  `message_primary`
  `schema_name`
  `severity`
  `source_file`
  `source_function`
  `source_line`
  `sqlstate`
  `statement_position`
  `table_name`

    A string with the error field if available; `None` if not available. The attribute value is available only if the error sent by the server: not all the fields are available for all the errors and for all the server versions.

`psycopg2.extensions.` `set_wait_callback`(f)

  Register a callback function to block waiting for data.

  The callback should have signature `fun(conn)` and is called to wait for data available whenever a blocking function from the libpq is called. Use `set_wait_callback(None)` to revert to the original behaviour (i.e. using blocking libpq functions).

  The function is an hook to allow coroutine-based libraries (such as Eventlet or gevent) to switch when Psycopg is blocked, allowing other coroutines to run concurrently.

  See `wait_select()` for an example of a wait callback implementation.

  New in version 2.2.0.

`psycopg2.extensions.` `get_wait_callback`()

  Return the currently registered wait callback.

  Return `None` if no callback is currently registered.

  New in version 2.2.0.

## SQL adaptation protocol objects

Psycopg provides a flexible system to adapt Python objects to the SQL syntax (inspired to the PEP 246), allowing serialization in PostgreSQL. See Adapting new Python types to SQL syntax for a detailed description. The following objects deal with Python objects adaptation:

`psycopg2.extensions.` `adapt`(obj)

  Return the SQL representation of obj as a string. Raise a `ProgrammingError` if how to adapt the object is unknown. In order to allow new objects to be adapted, register a new adapter for it using the `register_adapter()` function.

  The function is the entry point of the adaptation mechanism: it can be used to write adapters for complex objects by recursively calling `adapt()` on its components.

`psycopg2.extensions.` `register_adapter`(class, adapter)

  Register a new adapter for the objects of class class.

  adapter should be a function taking a single argument (the object to adapt) and returning an object conforming the `ISQLQuote` protocol (e.g. exposing a `getquoted()` method). The `AsIs` is often useful for this task.

  Once an object is registered, it can be safely used in SQL queries and by the `adapt()` function.

class `psycopg2.extensions.` `ISQLQuote`(wrapped_object)

  Represents the SQL adaptation protocol. Objects conforming this protocol should implement a `getquoted()` and optionally a `prepare()` method.

  Adapters may subclass `ISQLQuote`, but is not necessary: it is enough to expose a `getquoted()` method to be conforming.

  `_wrapped`

    The wrapped object passes to the constructor

  `getquoted`()

    Subclasses or other conforming objects should return a valid SQL string representing the wrapped object. In Python 3 the SQL must be returned in a `bytes` object. The `ISQLQuote` implementation does nothing.

  `prepare`(conn)

    Prepare the adapter for a connection. The method is optional: if implemented, it will be invoked before `getquoted()` with the connection to adapt for as argument.

    A conform object can implement this method if the SQL representation depends on any server parameter, such as the server version or the `standard_conforming_string` setting. Container objects may store the connection and use it to recursively prepare contained objects: see the implementation for `psycopg2.extensions.SQL_IN` for a simple example.

class `psycopg2.extensions.` `AsIs`(object)

  Adapter conform to the `ISQLQuote` protocol useful for objects whose string representation is already valid as SQL representation.

  `getquoted`()

    Return the `str()` conversion of the wrapped object.

        >>> AsIs(42).getquoted()
        '42'

class `psycopg2.extensions.` `QuotedString`(str)

  Adapter conform to the `ISQLQuote` protocol for string-like objects.

  `getquoted`()

    Return the string enclosed in single quotes. Any single quote appearing in the the string is escaped by doubling it according to SQL string constants syntax. Backslashes are escaped too.

        >>> QuotedString(r"O'Reilly").getquoted()
        "'O''Reilly'"

class `psycopg2.extensions.` `Binary`(str)

  Adapter conform to the `ISQLQuote` protocol for binary objects.

  `getquoted`()

    Return the string enclosed in single quotes. It performs the same escaping of the `QuotedString` adapter, plus it knows how to escape non-printable chars.

        >>> Binary("\x00\x08\x0F").getquoted()
        "'\\\\000\\\\010\\\\017'"

  Changed in version 2.0.14: previously the adapter was not exposed by the `extensions` module. In older versions it can be imported from the implementation module `psycopg2._psycopg`.

class `psycopg2.extensions.` `Boolean`
class `psycopg2.extensions.` `Float`
class `psycopg2.extensions.` `SQL_IN`

  Specialized adapters for builtin objects.

class `psycopg2.extensions.` `DateFromPy`
class `psycopg2.extensions.` `TimeFromPy`
class `psycopg2.extensions.` `TimestampFromPy`
class `psycopg2.extensions.` `IntervalFromPy`

  Specialized adapters for Python datetime objects.

class `psycopg2.extensions.` `DateFromMx`
class `psycopg2.extensions.` `TimeFromMx`
class `psycopg2.extensions.` `TimestampFromMx`
class `psycopg2.extensions.` `IntervalFromMx`

  Specialized adapters for mx.DateTime objects.

`psycopg2.extensions.` `adapters`

  Dictionary of the currently registered object adapters. Use `register_adapter()` to add an adapter for a new type.

## Database types casting functions

These functions are used to manipulate type casters to convert from PostgreSQL types to Python objects. See Type casting of SQL types into Python objects for details.

`psycopg2.extensions.` `new_type`(oids, name, adapter)

  Create a new type caster to convert from a PostgreSQL type to a Python object. The object created must be registered using `register_type()` to be used.

  Parameters: | oids – tuple of OIDs of the PostgreSQL type to convert. name – the name of the new type adapter. adapter – the adaptation function.

  The object OID can be read from the `cursor.description` attribute or by querying from the PostgreSQL catalog.

  adapter should have signature `fun(value, cur)` where value is the string representation returned by PostgreSQL and cur is the cursor from which data are read. In case of `NULL`, value will be `None`. The adapter should return the converted object.

  See Type casting of SQL types into Python objects for an usage example.

`psycopg2.extensions.` `new_array_type`(oids, name, base_caster)

  Create a new type caster to convert from a PostgreSQL array type to a list of Python object. The object created must be registered using `register_type()` to be used.

  Parameters: | oids – tuple of OIDs of the PostgreSQL type to convert. It should probably contain the oid of the array type (e.g. the `typarray` field in the `pg_type` table). name – the name of the new type adapter. base_caster – a Psycopg typecaster, e.g. created using the `new_type()` function. The caster should be able to parse a single item of the desired type.

  New in version 2.4.3.

  Note

  The function can be used to create a generic array typecaster, returning a list of strings: just use `psycopg2.STRING` as base typecaster. For instance, if you want to receive an array of `macaddr` from the database, each address represented by string, you can use:

      # select typarray from pg_type where typname = 'macaddr' -> 1040
      psycopg2.extensions.register_type(
          psycopg2.extensions.new_array_type(
              (1040,), 'MACADDR[]', psycopg2.STRING))

`psycopg2.extensions.` `register_type`(obj[, scope])

  Register a type caster created using `new_type()`.

  If scope is specified, it should be a `connection` or a `cursor`: the type caster will be effective only limited to the specified object. Otherwise it will be globally registered.

`psycopg2.extensions.` `string_types`

  The global register of type casters.

`psycopg2.extensions.` `encodings`

  Mapping from PostgreSQL encoding names to Python codec names. Used by Psycopg when adapting or casting unicode strings. See Unicode handling.

## Additional exceptions

The module exports a few exceptions in addition to the standard ones defined by the DB API 2.0.

exception `psycopg2.extensions.` `QueryCanceledError`

  (subclasses `OperationalError`)

  Error related to SQL query cancellation. It can be trapped specifically to detect a timeout.

  New in version 2.0.7.

exception `psycopg2.extensions.` `TransactionRollbackError`

  (subclasses `OperationalError`)

  Error causing transaction rollback (deadlocks, serialization failures, etc). It can be trapped specifically to detect a deadlock.

  New in version 2.0.7.

## Isolation level constants

Psycopg2 `connection` objects hold informations about the PostgreSQL transaction isolation level. The current transaction level can be read from the `isolation_level` attribute. The default isolation level is `READ COMMITTED`. A different isolation level con be set through the `set_isolation_level()` method. The level can be set to one of the following constants:

`psycopg2.extensions.` `ISOLATION_LEVEL_AUTOCOMMIT`

  No transaction is started when command are issued and no `commit()` or `rollback()` is required. Some PostgreSQL command such as `CREATE DATABASE` or `VACUUM` can’t run into a transaction: to run such command use:

      >>> conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)

  See also Transactions control.

`psycopg2.extensions.` `ISOLATION_LEVEL_READ_UNCOMMITTED`

  The `READ UNCOMMITTED` isolation level is defined in the SQL standard but not available in the MVCC model of PostgreSQL: it is replaced by the stricter `READ COMMITTED`.

`psycopg2.extensions.` `ISOLATION_LEVEL_READ_COMMITTED`

  This is usually the the default PostgreSQL value, but a different default may be set in the database configuration.

  A new transaction is started at the first `execute()` command on a cursor and at each new `execute()` after a `commit()` or a `rollback()`. The transaction runs in the PostgreSQL `READ COMMITTED` isolation level: a `SELECT` query sees only data committed before the query began; it never sees either uncommitted data or changes committed during query execution by concurrent transactions.

  See also

  Read Committed Isolation Level in PostgreSQL documentation.

`psycopg2.extensions.` `ISOLATION_LEVEL_REPEATABLE_READ`

  As in `ISOLATION_LEVEL_READ_COMMITTED`, a new transaction is started at the first `execute()` command. Transactions run at a `REPEATABLE READ` isolation level: all the queries in a transaction see a snapshot as of the start of the transaction, not as of the start of the current query within the transaction. However applications using this level must be prepared to retry transactions due to serialization failures.

  While this level provides a guarantee that each transaction sees a completely stable view of the database, this view will not necessarily always be consistent with some serial (one at a time) execution of concurrent transactions of the same level.

  Changed in version 2.4.2: The value was an alias for `ISOLATION_LEVEL_SERIALIZABLE` before. The two levels are distinct since PostgreSQL 9.1

  See also

  Repeatable Read Isolation Level in PostgreSQL documentation.

`psycopg2.extensions.` `ISOLATION_LEVEL_SERIALIZABLE`

  As in `ISOLATION_LEVEL_READ_COMMITTED`, a new transaction is started at the first `execute()` command. Transactions run at a `SERIALIZABLE` isolation level. This is the strictest transactions isolation level, equivalent to having the transactions executed serially rather than concurrently. However applications using this level must be prepared to retry transactions due to serialization failures.

  Starting from PostgreSQL 9.1, this mode monitors for conditions which could make execution of a concurrent set of serializable transactions behave in a manner inconsistent with all possible serial (one at a time) executions of those transaction. In previous version the behaviour was the same of the `REPEATABLE READ` isolation level.

  See also

  Serializable Isolation Level in PostgreSQL documentation.

## Transaction status constants

These values represent the possible status of a transaction: the current value can be read using the `connection.get_transaction_status()` method.

`psycopg2.extensions.` `TRANSACTION_STATUS_IDLE`

  The session is idle and there is no current transaction.

`psycopg2.extensions.` `TRANSACTION_STATUS_ACTIVE`

  A command is currently in progress.

`psycopg2.extensions.` `TRANSACTION_STATUS_INTRANS`

  The session is idle in a valid transaction block.

`psycopg2.extensions.` `TRANSACTION_STATUS_INERROR`

  The session is idle in a failed transaction block.

`psycopg2.extensions.` `TRANSACTION_STATUS_UNKNOWN`

  Reported if the connection with the server is bad.

## Connection status constants

These values represent the possible status of a connection: the current value can be read from the `status` attribute.

It is possible to find the connection in other status than the one shown below. Those are the only states in which a working connection is expected to be found during the execution of regular Python client code: other states are for internal usage and Python code should not rely on them.

`psycopg2.extensions.` `STATUS_READY`

  Connection established. No transaction in progress.

`psycopg2.extensions.` `STATUS_BEGIN`

  Connection established. A transaction is currently in progress.

`psycopg2.extensions.` `STATUS_IN_TRANSACTION`

  An alias for `STATUS_BEGIN`

`psycopg2.extensions.` `STATUS_PREPARED`

  The connection has been prepared for the second phase in a two-phase commit transaction. The connection can’t be used to send commands to the database until the transaction is finished with `tpc_commit()` or `tpc_rollback()`.

  New in version 2.3.

## Poll constants

New in version 2.2.0.

These values can be returned by `connection.poll()` during asynchronous connection and communication. They match the values in the libpq enum `PostgresPollingStatusType`. See Asynchronous support and Support for coroutine libraries.

`psycopg2.extensions.` `POLL_OK`

  The data being read is available, or the file descriptor is ready for writing: reading or writing will not block.

`psycopg2.extensions.` `POLL_READ`

  Some data is being read from the backend, but it is not available yet on the client and reading would block. Upon receiving this value, the client should wait for the connection file descriptor to be ready for reading. For example:

      select.select([conn.fileno()], [], [])

`psycopg2.extensions.` `POLL_WRITE`

  Some data is being sent to the backend but the connection file descriptor can’t currently accept new data. Upon receiving this value, the client should wait for the connection file descriptor to be ready for writing. For example:

      select.select([], [conn.fileno()], [])

`psycopg2.extensions.` `POLL_ERROR`

  There was a problem during connection polling. This value should actually never be returned: in case of poll error usually an exception containing the relevant details is raised.

## Additional database types

The `extensions` module includes typecasters for many standard PostgreSQL types. These objects allow the conversion of returned data into Python objects. All the typecasters are automatically registered, except `UNICODE` and `UNICODEARRAY`: you can register them using `register_type()` in order to receive Unicode objects instead of strings from the database. See Unicode handling for details.

`psycopg2.extensions.` `BOOLEAN`
`psycopg2.extensions.` `DATE`
`psycopg2.extensions.` `DECIMAL`
`psycopg2.extensions.` `FLOAT`
`psycopg2.extensions.` `INTEGER`
`psycopg2.extensions.` `INTERVAL`
`psycopg2.extensions.` `LONGINTEGER`
`psycopg2.extensions.` `TIME`
`psycopg2.extensions.` `UNICODE`

  Typecasters for basic types. Note that a few other ones (`BINARY`, `DATETIME`, `NUMBER`, `ROWID`, `STRING`) are exposed by the `psycopg2` module for DB API 2.0 compliance.

`psycopg2.extensions.` `BINARYARRAY`
`psycopg2.extensions.` `BOOLEANARRAY`
`psycopg2.extensions.` `DATEARRAY`
`psycopg2.extensions.` `DATETIMEARRAY`
`psycopg2.extensions.` `DECIMALARRAY`
`psycopg2.extensions.` `FLOATARRAY`
`psycopg2.extensions.` `INTEGERARRAY`
`psycopg2.extensions.` `INTERVALARRAY`
`psycopg2.extensions.` `LONGINTEGERARRAY`
`psycopg2.extensions.` `ROWIDARRAY`
`psycopg2.extensions.` `STRINGARRAY`
`psycopg2.extensions.` `TIMEARRAY`
`psycopg2.extensions.` `UNICODEARRAY`

  Typecasters to convert arrays of sql types into Python lists.

`psycopg2.extensions.` `PYDATE`
`psycopg2.extensions.` `PYDATETIME`
`psycopg2.extensions.` `PYINTERVAL`
`psycopg2.extensions.` `PYTIME`
`psycopg2.extensions.` `PYDATEARRAY`
`psycopg2.extensions.` `PYDATETIMEARRAY`
`psycopg2.extensions.` `PYINTERVALARRAY`
`psycopg2.extensions.` `PYTIMEARRAY`

  Typecasters to convert time-related data types to Python `datetime` objects.

`psycopg2.extensions.` `MXDATE`
`psycopg2.extensions.` `MXDATETIME`
`psycopg2.extensions.` `MXINTERVAL`
`psycopg2.extensions.` `MXTIME`
`psycopg2.extensions.` `MXDATEARRAY`
`psycopg2.extensions.` `MXDATETIMEARRAY`
`psycopg2.extensions.` `MXINTERVALARRAY`
`psycopg2.extensions.` `MXTIMEARRAY`

  Typecasters to convert time-related data types to mx.DateTime objects. Only available if Psycopg was compiled with `mx` support.

Changed in version 2.2.0: previously the `DECIMAL` typecaster and the specific time-related typecasters (`PY*` and `MX*`) were not exposed by the `extensions` module. In older versions they can be imported from the implementation module `psycopg2._psycopg`.

### Navigation

- index
- modules |
- next |
- previous |
- Psycopg 2.5.2 documentation »