U
|
¸ý°d*{ ã @ s d Z ddlmZ ddlmZ ddlZddlZddlm Z ddl
|
m Z ddl m Z ddl mZ dd lmZ dd
|
lmZ dd lmZ d d l
|
mZ d dl
|
mZ d dlmZ d dlmZ e d¡ZG dd deZG dd deZ G dd de j Z G dd de Z G dd de Z G d d d e Z!G d d d e Z"G d d! d!eZ#G d"d# d#eZ$G d$d% d%eZ%e%j& '¡ \Z(Z)G d&d' d'e Z*e*Z+dS )(aG
|
.. dialect:: postgresql+psycopg2
|
:name: psycopg2
|
:dbapi: psycopg2
|
:connectstring: postgresql+psycopg2://user:password@host:port/dbname[?key=value&key=value...]
|
:url: https://pypi.org/project/psycopg2/
|
|
.. _psycopg2_toplevel:
|
|
psycopg2 Connect Arguments
|
--------------------------
|
|
Keyword arguments that are specific to the SQLAlchemy psycopg2 dialect
|
may be passed to :func:`_sa.create_engine()`, and include the following:
|
|
|
* ``isolation_level``: This option, available for all PostgreSQL dialects,
|
includes the ``AUTOCOMMIT`` isolation level when using the psycopg2
|
dialect. This option sets the **default** isolation level for the
|
connection that is set immediately upon connection to the database before
|
the connection is pooled. This option is generally superseded by the more
|
modern :paramref:`_engine.Connection.execution_options.isolation_level`
|
execution option, detailed at :ref:`dbapi_autocommit`.
|
|
.. seealso::
|
|
:ref:`psycopg2_isolation_level`
|
|
:ref:`dbapi_autocommit`
|
|
|
* ``client_encoding``: sets the client encoding in a libpq-agnostic way,
|
using psycopg2's ``set_client_encoding()`` method.
|
|
.. seealso::
|
|
:ref:`psycopg2_unicode`
|
|
|
* ``executemany_mode``, ``executemany_batch_page_size``,
|
``executemany_values_page_size``: Allows use of psycopg2
|
extensions for optimizing "executemany"-style queries. See the referenced
|
section below for details.
|
|
.. seealso::
|
|
:ref:`psycopg2_executemany_mode`
|
|
.. tip::
|
|
The above keyword arguments are **dialect** keyword arguments, meaning
|
that they are passed as explicit keyword arguments to :func:`_sa.create_engine()`::
|
|
engine = create_engine(
|
"postgresql+psycopg2://scott:tiger@localhost/test",
|
isolation_level="SERIALIZABLE",
|
)
|
|
These should not be confused with **DBAPI** connect arguments, which
|
are passed as part of the :paramref:`_sa.create_engine.connect_args`
|
dictionary and/or are passed in the URL query string, as detailed in
|
the section :ref:`custom_dbapi_args`.
|
|
.. _psycopg2_ssl:
|
|
SSL Connections
|
---------------
|
|
The psycopg2 module has a connection argument named ``sslmode`` for
|
controlling its behavior regarding secure (SSL) connections. The default is
|
``sslmode=prefer``; it will attempt an SSL connection and if that fails it
|
will fall back to an unencrypted connection. ``sslmode=require`` may be used
|
to ensure that only secure connections are established. Consult the
|
psycopg2 / libpq documentation for further options that are available.
|
|
Note that ``sslmode`` is specific to psycopg2 so it is included in the
|
connection URI::
|
|
engine = sa.create_engine(
|
"postgresql+psycopg2://scott:tiger@192.168.0.199:5432/test?sslmode=require"
|
)
|
|
Unix Domain Connections
|
------------------------
|
|
psycopg2 supports connecting via Unix domain connections. When the ``host``
|
portion of the URL is omitted, SQLAlchemy passes ``None`` to psycopg2,
|
which specifies Unix-domain communication rather than TCP/IP communication::
|
|
create_engine("postgresql+psycopg2://user:password@/dbname")
|
|
By default, the socket file used is to connect to a Unix-domain socket
|
in ``/tmp``, or whatever socket directory was specified when PostgreSQL
|
was built. This value can be overridden by passing a pathname to psycopg2,
|
using ``host`` as an additional keyword argument::
|
|
create_engine("postgresql+psycopg2://user:password@/dbname?host=/var/lib/postgresql")
|
|
.. seealso::
|
|
`PQconnectdbParams \
|
<https://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-PQCONNECTDBPARAMS>`_
|
|
.. _psycopg2_multi_host:
|
|
Specifying multiple fallback hosts
|
-----------------------------------
|
|
psycopg2 supports multiple connection points in the connection string.
|
When the ``host`` parameter is used multiple times in the query section of
|
the URL, SQLAlchemy will create a single string of the host and port
|
information provided to make the connections. Tokens may consist of
|
``host::port`` or just ``host``; in the latter case, the default port
|
is selected by libpq. In the example below, three host connections
|
are specified, for ``HostA::PortA``, ``HostB`` connecting to the default port,
|
and ``HostC::PortC``::
|
|
create_engine(
|
"postgresql+psycopg2://user:password@/dbname?host=HostA:PortA&host=HostB&host=HostC:PortC"
|
)
|
|
As an alternative, libpq query string format also may be used; this specifies
|
``host`` and ``port`` as single query string arguments with comma-separated
|
lists - the default port can be chosen by indicating an empty value
|
in the comma separated list::
|
|
create_engine(
|
"postgresql+psycopg2://user:password@/dbname?host=HostA,HostB,HostC&port=PortA,,PortC"
|
)
|
|
With either URL style, connections to each host is attempted based on a
|
configurable strategy, which may be configured using the libpq
|
``target_session_attrs`` parameter. Per libpq this defaults to ``any``
|
which indicates a connection to each host is then attempted until a connection is successful.
|
Other strategies include ``primary``, ``prefer-standby``, etc. The complete
|
list is documented by PostgreSQL at
|
`libpq connection strings <https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING>`_.
|
|
For example, to indicate two hosts using the ``primary`` strategy::
|
|
create_engine(
|
"postgresql+psycopg2://user:password@/dbname?host=HostA:PortA&host=HostB&host=HostC:PortC&target_session_attrs=primary"
|
)
|
|
.. versionchanged:: 1.4.40 Port specification in psycopg2 multiple host format
|
is repaired, previously ports were not correctly interpreted in this context.
|
libpq comma-separated format is also now supported.
|
|
.. versionadded:: 1.3.20 Support for multiple hosts in PostgreSQL connection
|
string.
|
|
.. seealso::
|
|
`libpq connection strings <https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING>`_ - please refer
|
to this section in the libpq documentation for complete background on multiple host support.
|
|
|
Empty DSN Connections / Environment Variable Connections
|
---------------------------------------------------------
|
|
The psycopg2 DBAPI can connect to PostgreSQL by passing an empty DSN to the
|
libpq client library, which by default indicates to connect to a localhost
|
PostgreSQL database that is open for "trust" connections. This behavior can be
|
further tailored using a particular set of environment variables which are
|
prefixed with ``PG_...``, which are consumed by ``libpq`` to take the place of
|
any or all elements of the connection string.
|
|
For this form, the URL can be passed without any elements other than the
|
initial scheme::
|
|
engine = create_engine('postgresql+psycopg2://')
|
|
In the above form, a blank "dsn" string is passed to the ``psycopg2.connect()``
|
function which in turn represents an empty DSN passed to libpq.
|
|
.. versionadded:: 1.3.2 support for parameter-less connections with psycopg2.
|
|
.. seealso::
|
|
`Environment Variables\
|
<https://www.postgresql.org/docs/current/libpq-envars.html>`_ -
|
PostgreSQL documentation on how to use ``PG_...``
|
environment variables for connections.
|
|
.. _psycopg2_execution_options:
|
|
Per-Statement/Connection Execution Options
|
-------------------------------------------
|
|
The following DBAPI-specific options are respected when used with
|
:meth:`_engine.Connection.execution_options`,
|
:meth:`.Executable.execution_options`,
|
:meth:`_query.Query.execution_options`,
|
in addition to those not specific to DBAPIs:
|
|
* ``isolation_level`` - Set the transaction isolation level for the lifespan
|
of a :class:`_engine.Connection` (can only be set on a connection,
|
not a statement
|
or query). See :ref:`psycopg2_isolation_level`.
|
|
* ``stream_results`` - Enable or disable usage of psycopg2 server side
|
cursors - this feature makes use of "named" cursors in combination with
|
special result handling methods so that result rows are not fully buffered.
|
Defaults to False, meaning cursors are buffered by default.
|
|
* ``max_row_buffer`` - when using ``stream_results``, an integer value that
|
specifies the maximum number of rows to buffer at a time. This is
|
interpreted by the :class:`.BufferedRowCursorResult`, and if omitted the
|
buffer will grow to ultimately store 1000 rows at a time.
|
|
.. versionchanged:: 1.4 The ``max_row_buffer`` size can now be greater than
|
1000, and the buffer will grow to that size.
|
|
.. _psycopg2_batch_mode:
|
|
.. _psycopg2_executemany_mode:
|
|
Psycopg2 Fast Execution Helpers
|
-------------------------------
|
|
Modern versions of psycopg2 include a feature known as
|
`Fast Execution Helpers \
|
<https://initd.org/psycopg/docs/extras.html#fast-execution-helpers>`_, which
|
have been shown in benchmarking to improve psycopg2's executemany()
|
performance, primarily with INSERT statements, by at least
|
an order of magnitude.
|
|
SQLAlchemy implements a native form of the "insert many values"
|
handler that will rewrite a single-row INSERT statement to accommodate for
|
many values at once within an extended VALUES clause; this handler is
|
equivalent to psycopg2's ``execute_values()`` handler; an overview of this
|
feature and its configuration are at :ref:`engine_insertmanyvalues`.
|
|
.. versionadded:: 2.0 Replaced psycopg2's ``execute_values()`` fast execution
|
helper with a native SQLAlchemy mechanism referred towards as
|
:ref:`insertmanyvalues <engine_insertmanyvalues>`.
|
|
The psycopg2 dialect retains the ability to use the psycopg2-specific
|
``execute_batch()`` feature, although it is not expected that this is a widely
|
used feature. The use of this extension may be enabled using the
|
``executemany_mode`` flag which may be passed to :func:`_sa.create_engine`::
|
|
engine = create_engine(
|
"postgresql+psycopg2://scott:tiger@host/dbname",
|
executemany_mode='values_plus_batch')
|
|
|
Possible options for ``executemany_mode`` include:
|
|
* ``values_only`` - this is the default value. SQLAlchemy's native
|
:ref:`insertmanyvalues <engine_insertmanyvalues>` handler is used for qualifying
|
INSERT statements, assuming
|
:paramref:`_sa.create_engine.use_insertmanyvalues` is left at
|
its default value of ``True``. This handler rewrites simple
|
INSERT statements to include multiple VALUES clauses so that many
|
parameter sets can be inserted with one statement.
|
|
* ``'values_plus_batch'``- SQLAlchemy's native
|
:ref:`insertmanyvalues <engine_insertmanyvalues>` handler is used for qualifying
|
INSERT statements, assuming
|
:paramref:`_sa.create_engine.use_insertmanyvalues` is left at its default
|
value of ``True``. Then, psycopg2's ``execute_batch()`` handler is used for
|
qualifying UPDATE and DELETE statements when executed with multiple parameter
|
sets. When using this mode, the :attr:`_engine.CursorResult.rowcount`
|
attribute will not contain a value for executemany-style executions against
|
UPDATE and DELETE statements.
|
|
.. versionchanged:: 2.0 Removed the ``'batch'`` and ``'None'`` options
|
from psycopg2 ``executemany_mode``. Control over batching for INSERT
|
statements is now configured via the
|
:paramref:`_sa.create_engine.use_insertmanyvalues` engine-level parameter.
|
|
The term "qualifying statements" refers to the statement being executed
|
being a Core :func:`_expression.insert`, :func:`_expression.update`
|
or :func:`_expression.delete` construct, and **not** a plain textual SQL
|
string or one constructed using :func:`_expression.text`. It also may **not** be
|
a special "extension" statement such as an "ON CONFLICT" "upsert" statement.
|
When using the ORM, all insert/update/delete statements used by the ORM flush process
|
are qualifying.
|
|
The "page size" for the psycopg2 "batch" strategy can be affected
|
by using the ``executemany_batch_page_size`` parameter, which defaults to
|
100.
|
|
For the "insertmanyvalues" feature, the page size can be controlled using the
|
:paramref:`_sa.create_engine.insertmanyvalues_page_size` parameter,
|
which defaults to 1000. An example of modifying both parameters
|
is below::
|
|
engine = create_engine(
|
"postgresql+psycopg2://scott:tiger@host/dbname",
|
executemany_mode='values_plus_batch',
|
insertmanyvalues_page_size=5000, executemany_batch_page_size=500)
|
|
.. seealso::
|
|
:ref:`engine_insertmanyvalues` - background on "insertmanyvalues"
|
|
:ref:`tutorial_multiple_parameters` - General information on using the
|
:class:`_engine.Connection`
|
object to execute statements in such a way as to make
|
use of the DBAPI ``.executemany()`` method.
|
|
|
.. _psycopg2_unicode:
|
|
Unicode with Psycopg2
|
----------------------
|
|
The psycopg2 DBAPI driver supports Unicode data transparently.
|
|
The client character encoding can be controlled for the psycopg2 dialect
|
in the following ways:
|
|
* For PostgreSQL 9.1 and above, the ``client_encoding`` parameter may be
|
passed in the database URL; this parameter is consumed by the underlying
|
``libpq`` PostgreSQL client library::
|
|
engine = create_engine("postgresql+psycopg2://user:pass@host/dbname?client_encoding=utf8")
|
|
Alternatively, the above ``client_encoding`` value may be passed using
|
:paramref:`_sa.create_engine.connect_args` for programmatic establishment with
|
``libpq``::
|
|
engine = create_engine(
|
"postgresql+psycopg2://user:pass@host/dbname",
|
connect_args={'client_encoding': 'utf8'}
|
)
|
|
* For all PostgreSQL versions, psycopg2 supports a client-side encoding
|
value that will be passed to database connections when they are first
|
established. The SQLAlchemy psycopg2 dialect supports this using the
|
``client_encoding`` parameter passed to :func:`_sa.create_engine`::
|
|
engine = create_engine(
|
"postgresql+psycopg2://user:pass@host/dbname",
|
client_encoding="utf8"
|
)
|
|
.. tip:: The above ``client_encoding`` parameter admittedly is very similar
|
in appearance to usage of the parameter within the
|
:paramref:`_sa.create_engine.connect_args` dictionary; the difference
|
above is that the parameter is consumed by psycopg2 and is
|
passed to the database connection using ``SET client_encoding TO
|
'utf8'``; in the previously mentioned style, the parameter is instead
|
passed through psycopg2 and consumed by the ``libpq`` library.
|
|
* A common way to set up client encoding with PostgreSQL databases is to
|
ensure it is configured within the server-side postgresql.conf file;
|
this is the recommended way to set encoding for a server that is
|
consistently of one encoding in all databases::
|
|
# postgresql.conf file
|
|
# client_encoding = sql_ascii # actually, defaults to database
|
# encoding
|
client_encoding = utf8
|
|
|
|
Transactions
|
------------
|
|
The psycopg2 dialect fully supports SAVEPOINT and two-phase commit operations.
|
|
.. _psycopg2_isolation_level:
|
|
Psycopg2 Transaction Isolation Level
|
-------------------------------------
|
|
As discussed in :ref:`postgresql_isolation_level`,
|
all PostgreSQL dialects support setting of transaction isolation level
|
both via the ``isolation_level`` parameter passed to :func:`_sa.create_engine`
|
,
|
as well as the ``isolation_level`` argument used by
|
:meth:`_engine.Connection.execution_options`. When using the psycopg2 dialect
|
, these
|
options make use of psycopg2's ``set_isolation_level()`` connection method,
|
rather than emitting a PostgreSQL directive; this is because psycopg2's
|
API-level setting is always emitted at the start of each transaction in any
|
case.
|
|
The psycopg2 dialect supports these constants for isolation level:
|
|
* ``READ COMMITTED``
|
* ``READ UNCOMMITTED``
|
* ``REPEATABLE READ``
|
* ``SERIALIZABLE``
|
* ``AUTOCOMMIT``
|
|
.. seealso::
|
|
:ref:`postgresql_isolation_level`
|
|
:ref:`pg8000_isolation_level`
|
|
|
NOTICE logging
|
---------------
|
|
The psycopg2 dialect will log PostgreSQL NOTICE messages
|
via the ``sqlalchemy.dialects.postgresql`` logger. When this logger
|
is set to the ``logging.INFO`` level, notice messages will be logged::
|
|
import logging
|
|
logging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)
|
|
Above, it is assumed that logging is configured externally. If this is not
|
the case, configuration such as ``logging.basicConfig()`` must be utilized::
|
|
import logging
|
|
logging.basicConfig() # log messages to stdout
|
logging.getLogger('sqlalchemy.dialects.postgresql').setLevel(logging.INFO)
|
|
.. seealso::
|
|
`Logging HOWTO <https://docs.python.org/3/howto/logging.html>`_ - on the python.org website
|
|
.. _psycopg2_hstore:
|
|
HSTORE type
|
------------
|
|
The ``psycopg2`` DBAPI includes an extension to natively handle marshalling of
|
the HSTORE type. The SQLAlchemy psycopg2 dialect will enable this extension
|
by default when psycopg2 version 2.4 or greater is used, and
|
it is detected that the target database has the HSTORE type set up for use.
|
In other words, when the dialect makes the first
|
connection, a sequence like the following is performed:
|
|
1. Request the available HSTORE oids using
|
``psycopg2.extras.HstoreAdapter.get_oids()``.
|
If this function returns a list of HSTORE identifiers, we then determine
|
that the ``HSTORE`` extension is present.
|
This function is **skipped** if the version of psycopg2 installed is
|
less than version 2.4.
|
|
2. If the ``use_native_hstore`` flag is at its default of ``True``, and
|
we've detected that ``HSTORE`` oids are available, the
|
``psycopg2.extensions.register_hstore()`` extension is invoked for all
|
connections.
|
|
The ``register_hstore()`` extension has the effect of **all Python
|
dictionaries being accepted as parameters regardless of the type of target
|
column in SQL**. The dictionaries are converted by this extension into a
|
textual HSTORE expression. If this behavior is not desired, disable the
|
use of the hstore extension by setting ``use_native_hstore`` to ``False`` as
|
follows::
|
|
engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test",
|
use_native_hstore=False)
|
|
The ``HSTORE`` type is **still supported** when the
|
``psycopg2.extensions.register_hstore()`` extension is not used. It merely
|
means that the coercion between Python dictionaries and the HSTORE
|
string format, on both the parameter side and the result side, will take
|
place within SQLAlchemy's own marshalling logic, and not that of ``psycopg2``
|
which may be more performant.
|
|
é )Ú annotationsN)Úcasté )Úranges)Ú_PGDialect_common_psycopg)Ú"_PGExecutionContext_common_psycopg)ÚPGIdentifierPreparer)ÚJSON)ÚJSONBé )Útypes)Úutil)Ú FastIntFlag)Ú parse_user_argument_for_enumz sqlalchemy.dialects.postgresqlc @ s e Zd Zdd ZdS )Ú_PGJSONc C s d S ©N© ©ÚselfÚdialectÚcoltyper r ú^d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/postgresql/psycopg2.pyÚresult_processorí s z_PGJSON.result_processorN©Ú__name__Ú
|
__module__Ú __qualname__r r r r r r ì s r c @ s e Zd Zdd ZdS )Ú_PGJSONBc C s d S r r r r r r r ò s z_PGJSONB.result_processorNr r r r r r ñ s r c @ s e Zd ZdZdd Zdd ZdS )Ú_Psycopg2RangeÚnonec s$ t tt|j| j fdd}|S )Nc s& t | tjr" | j| j| j| j} | S r )Ú
|
isinstancer ÚRangeÚlowerÚupperÚboundsÚempty©Úvalue©Zpsycopg2_Ranger r Úto_rangeÿ s ÿz/_Psycopg2Range.bind_processor.<locals>.to_range)Úgetattrr ÚPGDialect_psycopg2Ú_psycopg2_extrasÚ_psycopg2_range_cls)r r r) r r( r Úbind_processorù s
|
þ z _Psycopg2Range.bind_processorc C s dd }|S )Nc S s2 | d k r.t j| j| j| jr | jnd| j d} | S )Nz[))r$ r% )r r! Z_lowerZ_upperZ_boundsr& r r r r) s üz1_Psycopg2Range.result_processor.<locals>.to_ranger )r r r r) r r r r s
|
z _Psycopg2Range.result_processorN)r r r r- r. r r r r r r ö s r c @ s e Zd ZdZdS )Ú_Psycopg2NumericRangeZ NumericRangeN©r r r r- r r r r r/ s r/ c @ s e Zd ZdZdS )Ú_Psycopg2DateRangeZ DateRangeNr0 r r r r r1 s r1 c @ s e Zd ZdZdS )Ú_Psycopg2DateTimeRangeZ DateTimeRangeNr0 r r r r r2 s r2 c @ s e Zd ZdZdS )Ú_Psycopg2DateTimeTZRangeZDateTimeTZRangeNr0 r r r r r3 " s r3 c @ s e Zd ZdZdd Zdd ZdS )ÚPGExecutionContext_psycopg2Nc C s | | j¡ d S r )Ú _log_noticesÚcursor©r r r r Ú post_exec) s z%PGExecutionContext_psycopg2.post_execc C sL |j jrt|j jtjs d S |j jD ]}t | ¡ ¡ q$g |j jd d
< d S r )Ú
|
connectionZnoticesr Úcollections_abcÚIterableÚloggerÚinfoÚrstrip)r r6 Únoticer r r r5 , s
|
ÿ z(PGExecutionContext_psycopg2._log_notices)r r r Z_psycopg2_fetched_rowsr8 r5 r r r r r4 & s r4 c @ s e Zd ZdS )Ú PGIdentifierPreparer_psycopg2N)r r r r r r r r@ > s r@ c @ s e Zd ZdZdZdS )ÚExecutemanyModer r N)r r r ÚEXECUTEMANY_VALUESÚ EXECUTEMANY_VALUES_PLUS_BATCHr r r r rA B s rA c sF e Zd ZdZdZdZdZdZeZ e
|
Z dZ dZ dZdZe ejeeejeeeejeej eej eej e ej e!ej"e#i ¡Zd1dd Z$ fd
|
d Z%e&d d Z'ej(dd Z)ej(dd Z*ej(dd Z+dd Z,dd Z-dd Z.dd Z/d d Z0d d Z1d2d!d"Z2d#d$ Z3d%d& Z4d3d'd(Z5d4d)d*Z6d5d+d,Z7ej8d-d. Z9d/d0 Z: Z;S )6r+ Úpsycopg2TZpyformatF)r r Ú values_onlyéd c K s t j| f| t|tdgtdgid| _|| _| jrt| jdrt
|
d| jj ¡}|rrt dd | dd d
|
¡D | _| jd k rtd d S ) NrE Zvalues_plus_batchÚexecutemany_modeÚ __version__z(\d+)\.(\d+)(?:\.(\d+))?c s s | ]}|d k rt |V qd S r )Úint)Ú.0Úxr r r Ú <genexpr> s z.PGDialect_psycopg2.__init__.<locals>.<genexpr>r é r )rM é z+psycopg2 version 2.7 or higher is required.)r Ú__init__r rB rC rG Úexecutemany_batch_page_sizeÚdbapiÚhasattrÚreÚmatchrH ÚtupleÚgroupÚpsycopg2_versionÚ ImportError)r rG rP ÚkwargsÚmr r r rO n s* þú ÿ
|
|
ÿzPGDialect_psycopg2.__init__c s6 t |¡ | jo"| |jj¡d k | _| jtk | _ d S r )
|
ÚsuperÚ
|
initializeÚuse_native_hstoreÚ _hstore_oidsr9 Údbapi_connectionÚ_has_native_hstorerG rC Ú supports_sane_multi_rowcount©r r9 ©Ú __class__r r r\ s ÿþÿz PGDialect_psycopg2.initializec C s dd l }|S )Nr )rD )ÚclsrD r r r Ú import_dbapi s z PGDialect_psycopg2.import_dbapic C s ddl m} |S )Nr )Ú
|
extensions)rD rg )re rg r r r Ú_psycopg2_extensions¡ s z'PGDialect_psycopg2._psycopg2_extensionsc C s ddl m} |S )Nr ©Úextras)rD rj )re rj r r r r, § s z#PGDialect_psycopg2._psycopg2_extrasc C s | j }|j|j|j|j|jdS )N)Z
|
AUTOCOMMITzREAD COMMITTEDzREAD UNCOMMITTEDzREPEATABLE READZ SERIALIZABLE)rh ZISOLATION_LEVEL_AUTOCOMMITZ ISOLATION_LEVEL_READ_COMMITTEDZ ISOLATION_LEVEL_READ_UNCOMMITTEDZ ISOLATION_LEVEL_REPEATABLE_READZ ISOLATION_LEVEL_SERIALIZABLE)r rg r r r Ú_isolation_lookup s ûz$PGDialect_psycopg2._isolation_lookupc C s | | j| ¡ d S r )Úset_isolation_levelrk )r r_ Úlevelr r r rl ¸ s z&PGDialect_psycopg2.set_isolation_levelc C s
|
||_ d S r ©Úreadonly©r r9 r' r r r Ú set_readonly» s z PGDialect_psycopg2.set_readonlyc C s |j S r rn rb r r r Ú get_readonly¾ s z PGDialect_psycopg2.get_readonlyc C s
|
||_ d S r ©Z
|
deferrablerp r r r Úset_deferrableÁ s z!PGDialect_psycopg2.set_deferrablec C s |j S r rs rb r r r Úget_deferrableÄ s z!PGDialect_psycopg2.get_deferrablec sª j g jd k r*fdd} |¡ jrF fdd} |¡ jrjjrj fdd} |¡ jrjr fdd} |¡ r¢fdd}|S d S d S )Nc s | j¡ d S r )Zset_client_encodingÚclient_encoding©Ú
|
dbapi_connr7 r r Ú
|
on_connectÍ s z1PGDialect_psycopg2.on_connect.<locals>.on_connectc s d | ¡ d S r )Z register_uuidrw ri r r ry Ô s c s< | ¡}|d k r8|\}}d|i}||d< j| f| d S )NÚoidÚ array_oid)r^ Zregister_hstore)rx Z hstore_oidsrz r{ Úkw©rj r r r ry Û s
|
c s$ j | jd j| jd d S )N)Úloads)Zregister_default_jsonÚ_json_deserializerZregister_default_jsonbrw r} r r ry ç s ÿ ÿc s D ] }|| qd S r r )rx Úfn)Úfnsr r ry ó s )r, rv ÚappendrQ r] r )r ry r )rj r r r ry Ç s$
|
|
|
|
|
z PGDialect_psycopg2.on_connectNc C sF | j tkr6| jr d| ji}ni }| jj|||f| n | ||¡ d S )NZ page_size)rG rC rP r, Z execute_batchZ executemany)r r6 Z statementÚ
|
parametersÚcontextrY r r r Údo_executemanyû s
|
ÿÿz!PGDialect_psycopg2.do_executemanyc C s |j |¡ d S r )r9 Z tpc_begin©r r9 Úxidr r r Údo_begin_twophase s z$PGDialect_psycopg2.do_begin_twophasec C s |j ¡ d S r )r9 Z tpc_preparer r r r Údo_prepare_twophase
|
s z&PGDialect_psycopg2.do_prepare_twophasec C s. |r$|j | jjkr| ¡ || n| d S r )Ústatusrh Z STATUS_READYÚrollback)r rx Z operationr Úrecoverr r r Ú _do_twophase s
|
|
z PGDialect_psycopg2._do_twophasec C s |j j}| j||j||d d S ©N)r )r9 r_ r Z tpc_rollback©r r9 r Z is_preparedr rx r r r Údo_rollback_twophase s ÿz'PGDialect_psycopg2.do_rollback_twophasec C s |j j}| j||j||d d S r )r9 r_ r Z
|
tpc_commitr r r r Údo_commit_twophase s ÿz%PGDialect_psycopg2.do_commit_twophasec C s6 | j }|j |¡}|d k r.|d r.|dd
S d S d S )Nr rM )r, Z HstoreAdapterZget_oids)r r_ rj Zoidsr r r r^ % s
|
z PGDialect_psycopg2._hstore_oidsc C sf t || jjrbt|ddr dS t| d¡d }dD ],}| |¡}|dkr4d|d |
kr4 dS q4dS )NÚclosedFTÚ
|
r )zterminating connectionzclosed the connectionzconnection not openz"could not receive data from serverz could not send data to serverzconnection already closedzcursor already closedz!losed the connection unexpectedlyz'connection has been closed unexpectedlyz.SSL error: decryption failed or bad record macz&SSL SYSCALL error: Bad file descriptorz SSL SYSCALL error: EOF detectedz&SSL SYSCALL error: Operation timed outz SSL SYSCALL error: Bad addressú")r rQ ÚErrorr* ÚstrÚ partitionÚfind)r Úer9 r6 Zstr_eÚmsgÚidxr r r Ú is_disconnect/ s
|
z PGDialect_psycopg2.is_disconnect)rE rF )N)F)TF)TF)<r r r ZdriverZsupports_statement_cacheZ supports_server_side_cursorsZdefault_paramstylera r4 Zexecution_ctx_clsr@ ÚpreparerrW Z!use_insertmanyvalues_wo_returningZreturns_native_bytesr` r Z update_copyr Zcolspecsr r Úsqltypesr
|
r r Z INT4RANGEr/ Z INT8RANGEZNUMRANGEZ DATERANGEr1 ZTSRANGEr2 Z TSTZRANGEr3 rO r\ Ú classmethodrf Zmemoized_propertyrh r, rk rl rq rr rt ru ry r
r r r r r Zmemoized_instancemethodr^ r Ú __classcell__r r rc r r+ M s ÷þ ý
|
!
|
|
|
|
|
4
|
|
ÿ
|
ÿ
|
|
r+ ),Ú__doc__Ú
|
__future__r Úcollections.abcÚabcr: ÚloggingrS Útypingr Ú r Z_psycopg_commonr r Úbaser Újsonr r
|
r r r r r Ú getLoggerr< r r ZAbstractRangeImplr r/ r1 r2 r3 r4 r@ rA Ú __members__ÚvaluesrB rC r+ r r r r r Ú<module> sJ Q
|
ý
|
