�
���ecg@sgdZd
dl
mZ
d
dlZd
dlZd
dlmZ
ddl	m
Z
ddl	mZ
ddl	m
Z
dd	l	mZ
dd
l	mZ
ddl	mZ
dd
l	mZ
ddl	mZ
ddl	mZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlm Z 
ddlmZ!
ddl"m#Z#
ddl$m%Z%
ddl$m&Z&
ddl$m'Z'
ddl$m(Z(
ddl$m)Z)
ddl$m*Z*
dd l$m+Z+
dd!l$m,Z,
dd"l$m-Z-
dd#l$m.Z.
dd$l$m/Z/
ej0d%ej1�Z2ej0d&ej1ej3B�Z4e5d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dd�d�d�d�d�d�d�d�d�d�d�d�d�gf�
Z6d�d�fZ7d�d�d�d�fZ8d�d�d�d�d�d�d�fZ9d�e j:f
d���YZ;d�e j<f
d���YZ=d�e j>f
d���YZ?e?Z@d�e j>f
d���YZAeAZBd�e j>f
d���YZCeCZDd�e j>f
d���YZEeEZFd�e j>f
d���YZGd�e j>f
d���YZHd�e j>f
d���YZId�e jJf
d���YZJd�e jKf
d���YZKd�e jLe jMfd���YZNeNZOd�e j>f
d���YZPePZQd�e j>f
d���YZeZRd�e j>f
d���YZSd�e jLe jTfd���YZUd�ejVf
d���YZWiejXe jX6eNe jY6eUe jT6ejZe j[jZ6ej[e j[6Z\i+ejXd�6ej]d�6ej[d�6ej^d�6ej_d�6ej`d�6ejad�6ejbd�6ejcd�6ejdd�6e*d�6e%d�6e-d�6e/d�6e'd�6e jed�6e jed�6e.d�6e+d�6e)d�6e,d�6e?d�6eAd�6ed�6ePd�6ePd�6eCd�6eEd�6eGd�6eHd�6eId�6e=d�6eJd�6eJd�6eJd�6eKd�6eKd�6e(d�6eKd�6e;d�6e&d�6eNd�6eSd�6Zfd�ejgf
d���YZhd�ejif
d���YZjd�ejkf
d���YZld�ejmf
d���YZnd�ejof
d���YZpd�ejqf
d���YZrd�ejqf
d���YZsd�ejtf
d���YZud�ejvf
d���YZwd�ejvf
d���YZxd�ejyf
d���YZzdS(�s��
.. dialect:: postgresql
    :name: PostgreSQL
    :full_support: 12, 13, 14, 15
    :normal_support: 9.6+
    :best_effort: 8+

.. _postgresql_sequences:

Sequences/SERIAL/IDENTITY
-------------------------

PostgreSQL supports sequences, and SQLAlchemy uses these as the default means
of creating new primary key values for integer-based primary key columns. When
creating tables, SQLAlchemy will issue the ``SERIAL`` datatype for
integer-based primary key columns, which generates a sequence and server side
default corresponding to the column.

To specify a specific named sequence to be used for primary key generation,
use the :func:`~sqlalchemy.schema.Sequence` construct::

    Table('sometable', metadata,
            Column('id', Integer, Sequence('some_id_seq'), primary_key=True)
        )

When SQLAlchemy issues a single INSERT statement, to fulfill the contract of
having the "last insert identifier" available, a RETURNING clause is added to
the INSERT statement which specifies the primary key columns should be
returned after the statement completes. The RETURNING functionality only takes
place if PostgreSQL 8.2 or later is in use. As a fallback approach, the
sequence, whether specified explicitly or implicitly via ``SERIAL``, is
executed independently beforehand, the returned value to be used in the
subsequent insert. Note that when an
:func:`~sqlalchemy.sql.expression.insert()` construct is executed using
"executemany" semantics, the "last inserted identifier" functionality does not
apply; no RETURNING clause is emitted nor is the sequence pre-executed in this
case.

To force the usage of RETURNING by default off, specify the flag
``implicit_returning=False`` to :func:`_sa.create_engine`.

PostgreSQL 10 and above IDENTITY columns
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

PostgreSQL 10 and above have a new IDENTITY feature that supersedes the use
of SERIAL. The :class:`_schema.Identity` construct in a
:class:`_schema.Column` can be used to control its behavior::

    from sqlalchemy import Table, Column, MetaData, Integer, Computed

    metadata = MetaData()

    data = Table(
        "data",
        metadata,
        Column(
            'id', Integer, Identity(start=42, cycle=True), primary_key=True
        ),
        Column('data', String)
    )

The CREATE TABLE for the above :class:`_schema.Table` object would be:

.. sourcecode:: sql

    CREATE TABLE data (
        id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 42 CYCLE),
        data VARCHAR,
        PRIMARY KEY (id)
    )

.. versionchanged::  1.4   Added :class:`_schema.Identity` construct
   in a :class:`_schema.Column` to specify the option of an autoincrementing
   column.

.. note::

   Previous versions of SQLAlchemy did not have built-in support for rendering
   of IDENTITY, and could use the following compilation hook to replace
   occurrences of SERIAL with IDENTITY::

       from sqlalchemy.schema import CreateColumn
       from sqlalchemy.ext.compiler import compiles


       @compiles(CreateColumn, 'postgresql')
       def use_identity(element, compiler, **kw):
           text = compiler.visit_create_column(element, **kw)
           text = text.replace(
               "SERIAL", "INT GENERATED BY DEFAULT AS IDENTITY"
            )
           return text

   Using the above, a table such as::

       t = Table(
           't', m,
           Column('id', Integer, primary_key=True),
           Column('data', String)
       )

   Will generate on the backing database as::

       CREATE TABLE t (
           id INT GENERATED BY DEFAULT AS IDENTITY,
           data VARCHAR,
           PRIMARY KEY (id)
       )

.. _postgresql_ss_cursors:

Server Side Cursors
-------------------

Server-side cursor support is available for the psycopg2, asyncpg
dialects and may also be available in others.

Server side cursors are enabled on a per-statement basis by using the
:paramref:`.Connection.execution_options.stream_results` connection execution
option::

    with engine.connect() as conn:
        result = conn.execution_options(stream_results=True).execute(text("select * from table"))

Note that some kinds of SQL statements may not be supported with
server side cursors; generally, only SQL statements that return rows should be
used with this option.

.. deprecated:: 1.4  The dialect-level server_side_cursors flag is deprecated
   and will be removed in a future release.  Please use the
   :paramref:`_engine.Connection.stream_results` execution option for
   unbuffered cursor support.

.. seealso::

    :ref:`engine_stream_results`

.. _postgresql_isolation_level:

Transaction Isolation Level
---------------------------

Most SQLAlchemy dialects support setting of transaction isolation level
using the :paramref:`_sa.create_engine.isolation_level` parameter
at the :func:`_sa.create_engine` level, and at the :class:`_engine.Connection`
level via the :paramref:`.Connection.execution_options.isolation_level`
parameter.

For PostgreSQL dialects, this feature works either by making use of the
DBAPI-specific features, such as psycopg2's isolation level flags which will
embed the isolation level setting inline with the ``"BEGIN"`` statement, or for
DBAPIs with no direct support by emitting ``SET SESSION CHARACTERISTICS AS
TRANSACTION ISOLATION LEVEL <level>`` ahead of the ``"BEGIN"`` statement
emitted by the DBAPI.   For the special AUTOCOMMIT isolation level,
DBAPI-specific techniques are used which is typically an ``.autocommit``
flag on the DBAPI connection object.

To set isolation level using :func:`_sa.create_engine`::

    engine = create_engine(
        "postgresql+pg8000://scott:tiger@localhost/test",
        isolation_level = "REPEATABLE READ"
    )

To set using per-connection execution options::

    with engine.connect() as conn:
        conn = conn.execution_options(
            isolation_level="REPEATABLE READ"
        )
        with conn.begin():
            # ... work with transaction

There are also more options for isolation level configurations, such as
"sub-engine" objects linked to a main :class:`_engine.Engine` which each apply
different isolation level settings.  See the discussion at
:ref:`dbapi_autocommit` for background.

Valid values for ``isolation_level`` on most PostgreSQL dialects include:

* ``READ COMMITTED``
* ``READ UNCOMMITTED``
* ``REPEATABLE READ``
* ``SERIALIZABLE``
* ``AUTOCOMMIT``

.. seealso::

    :ref:`dbapi_autocommit`

    :ref:`postgresql_readonly_deferrable`

    :ref:`psycopg2_isolation_level`

    :ref:`pg8000_isolation_level`

.. _postgresql_readonly_deferrable:

Setting READ ONLY / DEFERRABLE
------------------------------

Most PostgreSQL dialects support setting the "READ ONLY" and "DEFERRABLE"
characteristics of the transaction, which is in addition to the isolation level
setting. These two attributes can be established either in conjunction with or
independently of the isolation level by passing the ``postgresql_readonly`` and
``postgresql_deferrable`` flags with
:meth:`_engine.Connection.execution_options`.  The example below illustrates
passing the ``"SERIALIZABLE"`` isolation level at the same time as setting
"READ ONLY" and "DEFERRABLE"::

    with engine.connect() as conn:
        conn = conn.execution_options(
            isolation_level="SERIALIZABLE",
            postgresql_readonly=True,
            postgresql_deferrable=True
        )
        with conn.begin():
            #  ... work with transaction

Note that some DBAPIs such as asyncpg only support "readonly" with
SERIALIZABLE isolation.

.. versionadded:: 1.4 added support for the ``postgresql_readonly``
   and ``postgresql_deferrable`` execution options.

.. _postgresql_reset_on_return:

Temporary Table / Resource Reset for Connection Pooling
-------------------------------------------------------

The :class:`.QueuePool` connection pool implementation used
by the SQLAlchemy :class:`_sa.Engine` object includes
:ref:`reset on return <pool_reset_on_return>` behavior that will invoke
the DBAPI ``.rollback()`` method when connections are returned to the pool.
While this rollback will clear out the immediate state used by the previous
transaction, it does not cover a wider range of session-level state, including
temporary tables as well as other server state such as prepared statement
handles and statement caches.   The PostgreSQL database includes a variety
of commands which may be used to reset this state, including
``DISCARD``, ``RESET``, ``DEALLOCATE``, and ``UNLISTEN``.


To install
one or more of these commands as the means of performing reset-on-return,
the :meth:`.PoolEvents.reset` event hook may be used, as demonstrated
in the example below (**requires SQLAlchemy 1.4.43 or greater**). The implementation
will end transactions in progress as well as discard temporary tables
using the ``CLOSE``, ``RESET`` and ``DISCARD`` commands; see the PostgreSQL
documentation for background on what each of these statements do.

The :paramref:`_sa.create_engine.pool_reset_on_return` parameter
is set to ``None`` so that the custom scheme can replace the default behavior
completely.   The custom hook implementation calls ``.rollback()`` in any case,
as it's usually important that the DBAPI's own tracking of commit/rollback
will remain consistent with the state of the transaction::


    from sqlalchemy import create_engine
    from sqlalchemy import event

    postgresql_engine = create_engine(
        "postgresql+pyscopg2://scott:tiger@hostname/dbname",

        # disable default reset-on-return scheme
        pool_reset_on_return=None,
    )


    @event.listens_for(postgresql_engine, "reset")
    def _reset_postgresql(dbapi_connection, connection_record, reset_state):
        dbapi_connection.execute("CLOSE ALL")
        dbapi_connection.execute("RESET ALL")
        dbapi_connection.execute("DISCARD TEMP")

        # so that the DBAPI itself knows that the connection has been
        # reset
        dbapi_connection.rollback()

.. versionchanged:: 1.4.43  Ensured the :meth:`.PoolEvents.reset` event
   is invoked for all "reset" occurrences, so that it's appropriate
   as a place for custom "reset" handlers.   Previous schemes which
   use the :meth:`.PoolEvents.checkin` handler remain usable as well.

.. seealso::

    :ref:`pool_reset_on_return` - in the :ref:`pooling_toplevel` documentation

.. _postgresql_alternate_search_path:

Setting Alternate Search Paths on Connect
------------------------------------------

The PostgreSQL ``search_path`` variable refers to the list of schema names
that will be implicitly referred towards when a particular table or other
object is referenced in a SQL statement.  As detailed in the next section
:ref:`postgresql_schema_reflection`, SQLAlchemy is generally organized around
the concept of keeping this variable at its default value of ``public``,
however, in order to have it set to any arbitrary name or names when connections
are used automatically, the "SET SESSION search_path" command may be invoked
for all connections in a pool using the following event handler, as discussed
at :ref:`schema_set_default_connections`::

    from sqlalchemy import event
    from sqlalchemy import create_engine

    engine = create_engine("postgresql+psycopg2://scott:tiger@host/dbname")

    @event.listens_for(engine, "connect", insert=True)
    def set_search_path(dbapi_connection, connection_record):
        existing_autocommit = dbapi_connection.autocommit
        dbapi_connection.autocommit = True
        cursor = dbapi_connection.cursor()
        cursor.execute("SET SESSION search_path='%s'" % schema_name)
        cursor.close()
        dbapi_connection.autocommit = existing_autocommit

The reason the recipe is complicated by use of the ``.autocommit`` DBAPI
attribute is so that when the ``SET SESSION search_path`` directive is invoked,
it is invoked outside of the scope of any transaction and therefore will not
be reverted when the DBAPI connection has a rollback.

.. seealso::

  :ref:`schema_set_default_connections` - in the :ref:`metadata_toplevel` documentation




.. _postgresql_schema_reflection:

Remote-Schema Table Introspection and PostgreSQL search_path
------------------------------------------------------------

.. admonition:: Section Best Practices Summarized

    keep the ``search_path`` variable set to its default of ``public``, without
    any other schema names. For other schema names, name these explicitly
    within :class:`_schema.Table` definitions. Alternatively, the
    ``postgresql_ignore_search_path`` option will cause all reflected
    :class:`_schema.Table` objects to have a :attr:`_schema.Table.schema`
    attribute set up.

The PostgreSQL dialect can reflect tables from any schema, as outlined in
:ref:`metadata_reflection_schemas`.

With regards to tables which these :class:`_schema.Table`
objects refer to via foreign key constraint, a decision must be made as to how
the ``.schema`` is represented in those remote tables, in the case where that
remote schema name is also a member of the current
`PostgreSQL search path
<https://www.postgresql.org/docs/current/static/ddl-schemas.html#DDL-SCHEMAS-PATH>`_.

By default, the PostgreSQL dialect mimics the behavior encouraged by
PostgreSQL's own ``pg_get_constraintdef()`` builtin procedure.  This function
returns a sample definition for a particular foreign key constraint,
omitting the referenced schema name from that definition when the name is
also in the PostgreSQL schema search path.  The interaction below
illustrates this behavior::

    test=> CREATE TABLE test_schema.referred(id INTEGER PRIMARY KEY);
    CREATE TABLE
    test=> CREATE TABLE referring(
    test(>         id INTEGER PRIMARY KEY,
    test(>         referred_id INTEGER REFERENCES test_schema.referred(id));
    CREATE TABLE
    test=> SET search_path TO public, test_schema;
    test=> SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM
    test-> pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n
    test-> ON n.oid = c.relnamespace
    test-> JOIN pg_catalog.pg_constraint r  ON c.oid = r.conrelid
    test-> WHERE c.relname='referring' AND r.contype = 'f'
    test-> ;
                   pg_get_constraintdef
    ---------------------------------------------------
     FOREIGN KEY (referred_id) REFERENCES referred(id)
    (1 row)

Above, we created a table ``referred`` as a member of the remote schema
``test_schema``, however when we added ``test_schema`` to the
PG ``search_path`` and then asked ``pg_get_constraintdef()`` for the
``FOREIGN KEY`` syntax, ``test_schema`` was not included in the output of
the function.

On the other hand, if we set the search path back to the typical default
of ``public``::

    test=> SET search_path TO public;
    SET

The same query against ``pg_get_constraintdef()`` now returns the fully
schema-qualified name for us::

    test=> SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM
    test-> pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n
    test-> ON n.oid = c.relnamespace
    test-> JOIN pg_catalog.pg_constraint r  ON c.oid = r.conrelid
    test-> WHERE c.relname='referring' AND r.contype = 'f';
                         pg_get_constraintdef
    ---------------------------------------------------------------
     FOREIGN KEY (referred_id) REFERENCES test_schema.referred(id)
    (1 row)

SQLAlchemy will by default use the return value of ``pg_get_constraintdef()``
in order to determine the remote schema name.  That is, if our ``search_path``
were set to include ``test_schema``, and we invoked a table
reflection process as follows::

    >>> from sqlalchemy import Table, MetaData, create_engine, text
    >>> engine = create_engine("postgresql://scott:tiger@localhost/test")
    >>> with engine.connect() as conn:
    ...     conn.execute(text("SET search_path TO test_schema, public"))
    ...     metadata_obj = MetaData()
    ...     referring = Table('referring', metadata_obj,
    ...                       autoload_with=conn)
    ...
    <sqlalchemy.engine.result.CursorResult object at 0x101612ed0>

The above process would deliver to the :attr:`_schema.MetaData.tables`
collection
``referred`` table named **without** the schema::

    >>> metadata_obj.tables['referred'].schema is None
    True

To alter the behavior of reflection such that the referred schema is
maintained regardless of the ``search_path`` setting, use the
``postgresql_ignore_search_path`` option, which can be specified as a
dialect-specific argument to both :class:`_schema.Table` as well as
:meth:`_schema.MetaData.reflect`::

    >>> with engine.connect() as conn:
    ...     conn.execute(text("SET search_path TO test_schema, public"))
    ...     metadata_obj = MetaData()
    ...     referring = Table('referring', metadata_obj,
    ...                       autoload_with=conn,
    ...                       postgresql_ignore_search_path=True)
    ...
    <sqlalchemy.engine.result.CursorResult object at 0x1016126d0>

We will now have ``test_schema.referred`` stored as schema-qualified::

    >>> metadata_obj.tables['test_schema.referred'].schema
    'test_schema'

.. sidebar:: Best Practices for PostgreSQL Schema reflection

    The description of PostgreSQL schema reflection behavior is complex, and
    is the product of many years of dealing with widely varied use cases and
    user preferences. But in fact, there's no need to understand any of it if
    you just stick to the simplest use pattern: leave the ``search_path`` set
    to its default of ``public`` only, never refer to the name ``public`` as
    an explicit schema name otherwise, and refer to all other schema names
    explicitly when building up a :class:`_schema.Table` object.  The options
    described here are only for those users who can't, or prefer not to, stay
    within these guidelines.

Note that **in all cases**, the "default" schema is always reflected as
``None``. The "default" schema on PostgreSQL is that which is returned by the
PostgreSQL ``current_schema()`` function.  On a typical PostgreSQL
installation, this is the name ``public``.  So a table that refers to another
which is in the ``public`` (i.e. default) schema will always have the
``.schema`` attribute set to ``None``.

.. seealso::

    :ref:`reflection_schema_qualified_interaction` - discussion of the issue
    from a backend-agnostic perspective

    `The Schema Search Path
    <https://www.postgresql.org/docs/current/static/ddl-schemas.html#DDL-SCHEMAS-PATH>`_
    - on the PostgreSQL website.

INSERT/UPDATE...RETURNING
-------------------------

The dialect supports PG 8.2's ``INSERT..RETURNING``, ``UPDATE..RETURNING`` and
``DELETE..RETURNING`` syntaxes.   ``INSERT..RETURNING`` is used by default
for single-row INSERT statements in order to fetch newly generated
primary key identifiers.   To specify an explicit ``RETURNING`` clause,
use the :meth:`._UpdateBase.returning` method on a per-statement basis::

    # INSERT..RETURNING
    result = table.insert().returning(table.c.col1, table.c.col2).\
        values(name='foo')
    print(result.fetchall())

    # UPDATE..RETURNING
    result = table.update().returning(table.c.col1, table.c.col2).\
        where(table.c.name=='foo').values(name='bar')
    print(result.fetchall())

    # DELETE..RETURNING
    result = table.delete().returning(table.c.col1, table.c.col2).\
        where(table.c.name=='foo')
    print(result.fetchall())

.. _postgresql_insert_on_conflict:

INSERT...ON CONFLICT (Upsert)
------------------------------

Starting with version 9.5, PostgreSQL allows "upserts" (update or insert) of
rows into a table via the ``ON CONFLICT`` clause of the ``INSERT`` statement. A
candidate row will only be inserted if that row does not violate any unique
constraints.  In the case of a unique constraint violation, a secondary action
can occur which can be either "DO UPDATE", indicating that the data in the
target row should be updated, or "DO NOTHING", which indicates to silently skip
this row.

Conflicts are determined using existing unique constraints and indexes.  These
constraints may be identified either using their name as stated in DDL,
or they may be inferred by stating the columns and conditions that comprise
the indexes.

SQLAlchemy provides ``ON CONFLICT`` support via the PostgreSQL-specific
:func:`_postgresql.insert()` function, which provides
the generative methods :meth:`_postgresql.Insert.on_conflict_do_update`
and :meth:`~.postgresql.Insert.on_conflict_do_nothing`:

.. sourcecode:: pycon+sql

    >>> from sqlalchemy.dialects.postgresql import insert
    >>> insert_stmt = insert(my_table).values(
    ...     id='some_existing_id',
    ...     data='inserted value')
    >>> do_nothing_stmt = insert_stmt.on_conflict_do_nothing(
    ...     index_elements=['id']
    ... )
    >>> print(do_nothing_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO NOTHING
    {stop}

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     constraint='pk_my_table',
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT ON CONSTRAINT pk_my_table DO UPDATE SET data = %(param_1)s

.. versionadded:: 1.1

.. seealso::

    `INSERT .. ON CONFLICT
    <https://www.postgresql.org/docs/current/static/sql-insert.html#SQL-ON-CONFLICT>`_
    - in the PostgreSQL documentation.

Specifying the Target
^^^^^^^^^^^^^^^^^^^^^

Both methods supply the "target" of the conflict using either the
named constraint or by column inference:

* The :paramref:`_postgresql.Insert.on_conflict_do_update.index_elements` argument
  specifies a sequence containing string column names, :class:`_schema.Column`
  objects, and/or SQL expression elements, which would identify a unique
  index:

  .. sourcecode:: pycon+sql

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     index_elements=['id'],
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s
    {stop}

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     index_elements=[my_table.c.id],
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s

* When using :paramref:`_postgresql.Insert.on_conflict_do_update.index_elements` to
  infer an index, a partial index can be inferred by also specifying the
  use the :paramref:`_postgresql.Insert.on_conflict_do_update.index_where` parameter:

  .. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(user_email='a@b.com', data='inserted data')
    >>> stmt = stmt.on_conflict_do_update(
    ...     index_elements=[my_table.c.user_email],
    ...     index_where=my_table.c.user_email.like('%@gmail.com'),
    ...     set_=dict(data=stmt.excluded.data)
    ... )
    >>> print(stmt)
    {opensql}INSERT INTO my_table (data, user_email)
    VALUES (%(data)s, %(user_email)s) ON CONFLICT (user_email)
    WHERE user_email LIKE %(user_email_1)s DO UPDATE SET data = excluded.data

* The :paramref:`_postgresql.Insert.on_conflict_do_update.constraint` argument is
  used to specify an index directly rather than inferring it.  This can be
  the name of a UNIQUE constraint, a PRIMARY KEY constraint, or an INDEX:

  .. sourcecode:: pycon+sql

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     constraint='my_table_idx_1',
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT ON CONSTRAINT my_table_idx_1 DO UPDATE SET data = %(param_1)s
    {stop}

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     constraint='my_table_pk',
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT ON CONSTRAINT my_table_pk DO UPDATE SET data = %(param_1)s
    {stop}

* The :paramref:`_postgresql.Insert.on_conflict_do_update.constraint` argument may
  also refer to a SQLAlchemy construct representing a constraint,
  e.g. :class:`.UniqueConstraint`, :class:`.PrimaryKeyConstraint`,
  :class:`.Index`, or :class:`.ExcludeConstraint`.   In this use,
  if the constraint has a name, it is used directly.  Otherwise, if the
  constraint is unnamed, then inference will be used, where the expressions
  and optional WHERE clause of the constraint will be spelled out in the
  construct.  This use is especially convenient
  to refer to the named or unnamed primary key of a :class:`_schema.Table`
  using the
  :attr:`_schema.Table.primary_key` attribute:

  .. sourcecode:: pycon+sql

    >>> do_update_stmt = insert_stmt.on_conflict_do_update(
    ...     constraint=my_table.primary_key,
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s

The SET Clause
^^^^^^^^^^^^^^^

``ON CONFLICT...DO UPDATE`` is used to perform an update of the already
existing row, using any combination of new values as well as values
from the proposed insertion.   These values are specified using the
:paramref:`_postgresql.Insert.on_conflict_do_update.set_` parameter.  This
parameter accepts a dictionary which consists of direct values
for UPDATE:

.. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(id='some_id', data='inserted value')
    >>> do_update_stmt = stmt.on_conflict_do_update(
    ...     index_elements=['id'],
    ...     set_=dict(data='updated value')
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s

.. warning::

    The :meth:`_expression.Insert.on_conflict_do_update`
    method does **not** take into
    account Python-side default UPDATE values or generation functions, e.g.
    those specified using :paramref:`_schema.Column.onupdate`.
    These values will not be exercised for an ON CONFLICT style of UPDATE,
    unless they are manually specified in the
    :paramref:`_postgresql.Insert.on_conflict_do_update.set_` dictionary.

Updating using the Excluded INSERT Values
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

In order to refer to the proposed insertion row, the special alias
:attr:`~.postgresql.Insert.excluded` is available as an attribute on
the :class:`_postgresql.Insert` object; this object is a
:class:`_expression.ColumnCollection`
which alias contains all columns of the target
table:

.. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(
    ...     id='some_id',
    ...     data='inserted value',
    ...     author='jlh'
    ... )
    >>> do_update_stmt = stmt.on_conflict_do_update(
    ...     index_elements=['id'],
    ...     set_=dict(data='updated value', author=stmt.excluded.author)
    ... )
    >>> print(do_update_stmt)
    {opensql}INSERT INTO my_table (id, data, author)
    VALUES (%(id)s, %(data)s, %(author)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s, author = excluded.author

Additional WHERE Criteria
^^^^^^^^^^^^^^^^^^^^^^^^^

The :meth:`_expression.Insert.on_conflict_do_update` method also accepts
a WHERE clause using the :paramref:`_postgresql.Insert.on_conflict_do_update.where`
parameter, which will limit those rows which receive an UPDATE:

.. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(
    ...     id='some_id',
    ...     data='inserted value',
    ...     author='jlh'
    ... )
    >>> on_update_stmt = stmt.on_conflict_do_update(
    ...     index_elements=['id'],
    ...     set_=dict(data='updated value', author=stmt.excluded.author),
    ...     where=(my_table.c.status == 2)
    ... )
    >>> print(on_update_stmt)
    {opensql}INSERT INTO my_table (id, data, author)
    VALUES (%(id)s, %(data)s, %(author)s)
    ON CONFLICT (id) DO UPDATE SET data = %(param_1)s, author = excluded.author
    WHERE my_table.status = %(status_1)s

Skipping Rows with DO NOTHING
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

``ON CONFLICT`` may be used to skip inserting a row entirely
if any conflict with a unique or exclusion constraint occurs; below
this is illustrated using the
:meth:`~.postgresql.Insert.on_conflict_do_nothing` method:

.. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(id='some_id', data='inserted value')
    >>> stmt = stmt.on_conflict_do_nothing(index_elements=['id'])
    >>> print(stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT (id) DO NOTHING

If ``DO NOTHING`` is used without specifying any columns or constraint,
it has the effect of skipping the INSERT for any unique or exclusion
constraint violation which occurs:

.. sourcecode:: pycon+sql

    >>> stmt = insert(my_table).values(id='some_id', data='inserted value')
    >>> stmt = stmt.on_conflict_do_nothing()
    >>> print(stmt)
    {opensql}INSERT INTO my_table (id, data) VALUES (%(id)s, %(data)s)
    ON CONFLICT DO NOTHING

.. _postgresql_match:

Full Text Search
----------------

SQLAlchemy makes available the PostgreSQL ``@@`` operator via the
:meth:`_expression.ColumnElement.match` method on any textual column expression.

On the PostgreSQL dialect, an expression like the following::

    select(sometable.c.text.match("search string"))

will emit to the database::

    SELECT text @@ to_tsquery('search string') FROM table

Various other PostgreSQL text search functions such as ``to_tsquery()``,
``to_tsvector()``, and ``plainto_tsquery()`` are available by explicitly using
the standard SQLAlchemy :data:`.func` construct.

For example::

    select(func.to_tsvector('fat cats ate rats').match('cat & rat'))

Emits the equivalent of::

    SELECT to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')

The :class:`_postgresql.TSVECTOR` type can provide for explicit CAST::

    from sqlalchemy.dialects.postgresql import TSVECTOR
    from sqlalchemy import select, cast
    select(cast("some text", TSVECTOR))

produces a statement equivalent to::

    SELECT CAST('some text' AS TSVECTOR) AS anon_1

.. tip::

    It's important to remember that text searching in PostgreSQL is powerful but complicated,
    and SQLAlchemy users are advised to reference the PostgreSQL documentation
    regarding
    `Full Text Search <https://www.postgresql.org/docs/current/textsearch-controls.html>`_.

    There are important differences between ``to_tsquery`` and
    ``plainto_tsquery``, the most significant of which is that ``to_tsquery``
    expects specially formatted "querytext" that is written to PostgreSQL's own
    specification, while ``plainto_tsquery`` expects unformatted text that is
    transformed into ``to_tsquery`` compatible querytext. This means the input to
    ``.match()`` under PostgreSQL may be incompatible with the input to
    ``.match()`` under another database backend. SQLAlchemy users who support
    multiple backends are advised to carefully implement their usage of
    ``.match()`` to work around these constraints.

Full Text Searches in PostgreSQL are influenced by a combination of: the
PostgreSQL setting of ``default_text_search_config``, the ``regconfig`` used
to build the GIN/GiST indexes, and the ``regconfig`` optionally passed in
during a query.

When performing a Full Text Search against a column that has a GIN or
GiST index that is already pre-computed (which is common on full text
searches) one may need to explicitly pass in a particular PostgreSQL
``regconfig`` value to ensure the query-planner utilizes the index and does
not re-compute the column on demand.

In order to provide for this explicit query planning, or to use different
search strategies, the ``match`` method accepts a ``postgresql_regconfig``
keyword argument::

    select(mytable.c.id).where(
        mytable.c.title.match('somestring', postgresql_regconfig='english')
    )

Emits the equivalent of::

    SELECT mytable.id FROM mytable
    WHERE mytable.title @@ to_tsquery('english', 'somestring')

One can also specifically pass in a `'regconfig'` value to the
``to_tsvector()`` command as the initial argument::

    select(mytable.c.id).where(
            func.to_tsvector('english', mytable.c.title )\
            .match('somestring', postgresql_regconfig='english')
        )

produces a statement equivalent to::

    SELECT mytable.id FROM mytable
    WHERE to_tsvector('english', mytable.title) @@
        to_tsquery('english', 'somestring')

It is recommended that you use the ``EXPLAIN ANALYZE...`` tool from
PostgreSQL to ensure that you are generating queries with SQLAlchemy that
take full advantage of any indexes you may have created for full text search.

.. seealso::

    `Full Text Search <https://www.postgresql.org/docs/current/textsearch-controls.html>`_ - in the PostgreSQL documentation


FROM ONLY ...
-------------

The dialect supports PostgreSQL's ONLY keyword for targeting only a particular
table in an inheritance hierarchy. This can be used to produce the
``SELECT ... FROM ONLY``, ``UPDATE ONLY ...``, and ``DELETE FROM ONLY ...``
syntaxes. It uses SQLAlchemy's hints mechanism::

    # SELECT ... FROM ONLY ...
    result = table.select().with_hint(table, 'ONLY', 'postgresql')
    print(result.fetchall())

    # UPDATE ONLY ...
    table.update(values=dict(foo='bar')).with_hint('ONLY',
                                                   dialect_name='postgresql')

    # DELETE FROM ONLY ...
    table.delete().with_hint('ONLY', dialect_name='postgresql')


.. _postgresql_indexes:

PostgreSQL-Specific Index Options
---------------------------------

Several extensions to the :class:`.Index` construct are available, specific
to the PostgreSQL dialect.

Covering Indexes
^^^^^^^^^^^^^^^^

The ``postgresql_include`` option renders INCLUDE(colname) for the given
string names::

    Index("my_index", table.c.x, postgresql_include=['y'])

would render the index as ``CREATE INDEX my_index ON table (x) INCLUDE (y)``

Note that this feature requires PostgreSQL 11 or later.

.. versionadded:: 1.4

.. _postgresql_partial_indexes:

Partial Indexes
^^^^^^^^^^^^^^^

Partial indexes add criterion to the index definition so that the index is
applied to a subset of rows.   These can be specified on :class:`.Index`
using the ``postgresql_where`` keyword argument::

  Index('my_index', my_table.c.id, postgresql_where=my_table.c.value > 10)

.. _postgresql_operator_classes:

Operator Classes
^^^^^^^^^^^^^^^^

PostgreSQL allows the specification of an *operator class* for each column of
an index (see
https://www.postgresql.org/docs/current/interactive/indexes-opclass.html).
The :class:`.Index` construct allows these to be specified via the
``postgresql_ops`` keyword argument::

    Index(
        'my_index', my_table.c.id, my_table.c.data,
        postgresql_ops={
            'data': 'text_pattern_ops',
            'id': 'int4_ops'
        })

Note that the keys in the ``postgresql_ops`` dictionaries are the
"key" name of the :class:`_schema.Column`, i.e. the name used to access it from
the ``.c`` collection of :class:`_schema.Table`, which can be configured to be
different than the actual name of the column as expressed in the database.

If ``postgresql_ops`` is to be used against a complex SQL expression such
as a function call, then to apply to the column it must be given a label
that is identified in the dictionary by name, e.g.::

    Index(
        'my_index', my_table.c.id,
        func.lower(my_table.c.data).label('data_lower'),
        postgresql_ops={
            'data_lower': 'text_pattern_ops',
            'id': 'int4_ops'
        })

Operator classes are also supported by the
:class:`_postgresql.ExcludeConstraint` construct using the
:paramref:`_postgresql.ExcludeConstraint.ops` parameter. See that parameter for
details.

.. versionadded:: 1.3.21 added support for operator classes with
   :class:`_postgresql.ExcludeConstraint`.


Index Types
^^^^^^^^^^^

PostgreSQL provides several index types: B-Tree, Hash, GiST, and GIN, as well
as the ability for users to create their own (see
https://www.postgresql.org/docs/current/static/indexes-types.html). These can be
specified on :class:`.Index` using the ``postgresql_using`` keyword argument::

    Index('my_index', my_table.c.data, postgresql_using='gin')

The value passed to the keyword argument will be simply passed through to the
underlying CREATE INDEX command, so it *must* be a valid index type for your
version of PostgreSQL.

.. _postgresql_index_storage:

Index Storage Parameters
^^^^^^^^^^^^^^^^^^^^^^^^

PostgreSQL allows storage parameters to be set on indexes. The storage
parameters available depend on the index method used by the index. Storage
parameters can be specified on :class:`.Index` using the ``postgresql_with``
keyword argument::

    Index('my_index', my_table.c.data, postgresql_with={"fillfactor": 50})

.. versionadded:: 1.0.6

PostgreSQL allows to define the tablespace in which to create the index.
The tablespace can be specified on :class:`.Index` using the
``postgresql_tablespace`` keyword argument::

    Index('my_index', my_table.c.data, postgresql_tablespace='my_tablespace')

.. versionadded:: 1.1

Note that the same option is available on :class:`_schema.Table` as well.

.. _postgresql_index_concurrently:

Indexes with CONCURRENTLY
^^^^^^^^^^^^^^^^^^^^^^^^^

The PostgreSQL index option CONCURRENTLY is supported by passing the
flag ``postgresql_concurrently`` to the :class:`.Index` construct::

    tbl = Table('testtbl', m, Column('data', Integer))

    idx1 = Index('test_idx1', tbl.c.data, postgresql_concurrently=True)

The above index construct will render DDL for CREATE INDEX, assuming
PostgreSQL 8.2 or higher is detected or for a connection-less dialect, as::

    CREATE INDEX CONCURRENTLY test_idx1 ON testtbl (data)

For DROP INDEX, assuming PostgreSQL 9.2 or higher is detected or for
a connection-less dialect, it will emit::

    DROP INDEX CONCURRENTLY test_idx1

.. versionadded:: 1.1 support for CONCURRENTLY on DROP INDEX.  The
   CONCURRENTLY keyword is now only emitted if a high enough version
   of PostgreSQL is detected on the connection (or for a connection-less
   dialect).

When using CONCURRENTLY, the PostgreSQL database requires that the statement
be invoked outside of a transaction block.   The Python DBAPI enforces that
even for a single statement, a transaction is present, so to use this
construct, the DBAPI's "autocommit" mode must be used::

    metadata = MetaData()
    table = Table(
        "foo", metadata,
        Column("id", String))
    index = Index(
        "foo_idx", table.c.id, postgresql_concurrently=True)

    with engine.connect() as conn:
        with conn.execution_options(isolation_level='AUTOCOMMIT'):
            table.create(conn)

.. seealso::

    :ref:`postgresql_isolation_level`

.. _postgresql_index_reflection:

PostgreSQL Index Reflection
---------------------------

The PostgreSQL database creates a UNIQUE INDEX implicitly whenever the
UNIQUE CONSTRAINT construct is used.   When inspecting a table using
:class:`_reflection.Inspector`, the :meth:`_reflection.Inspector.get_indexes`
and the :meth:`_reflection.Inspector.get_unique_constraints`
will report on these
two constructs distinctly; in the case of the index, the key
``duplicates_constraint`` will be present in the index entry if it is
detected as mirroring a constraint.   When performing reflection using
``Table(..., autoload_with=engine)``, the UNIQUE INDEX is **not** returned
in :attr:`_schema.Table.indexes` when it is detected as mirroring a
:class:`.UniqueConstraint` in the :attr:`_schema.Table.constraints` collection
.

.. versionchanged:: 1.0.0 - :class:`_schema.Table` reflection now includes
   :class:`.UniqueConstraint` objects present in the
   :attr:`_schema.Table.constraints`
   collection; the PostgreSQL backend will no longer include a "mirrored"
   :class:`.Index` construct in :attr:`_schema.Table.indexes`
   if it is detected
   as corresponding to a unique constraint.

Special Reflection Options
--------------------------

The :class:`_reflection.Inspector`
used for the PostgreSQL backend is an instance
of :class:`.PGInspector`, which offers additional methods::

    from sqlalchemy import create_engine, inspect

    engine = create_engine("postgresql+psycopg2://localhost/test")
    insp = inspect(engine)  # will be a PGInspector

    print(insp.get_enums())

.. autoclass:: PGInspector
    :members:

.. _postgresql_table_options:

PostgreSQL Table Options
------------------------

Several options for CREATE TABLE are supported directly by the PostgreSQL
dialect in conjunction with the :class:`_schema.Table` construct:

* ``TABLESPACE``::

    Table("some_table", metadata, ..., postgresql_tablespace='some_tablespace')

  The above option is also available on the :class:`.Index` construct.

* ``ON COMMIT``::

    Table("some_table", metadata, ..., postgresql_on_commit='PRESERVE ROWS')

* ``WITH OIDS``::

    Table("some_table", metadata, ..., postgresql_with_oids=True)

* ``WITHOUT OIDS``::

    Table("some_table", metadata, ..., postgresql_with_oids=False)

* ``INHERITS``::

    Table("some_table", metadata, ..., postgresql_inherits="some_supertable")

    Table("some_table", metadata, ..., postgresql_inherits=("t1", "t2", ...))

    .. versionadded:: 1.0.0

* ``PARTITION BY``::

    Table("some_table", metadata, ...,
          postgresql_partition_by='LIST (part_column)')

    .. versionadded:: 1.2.6

.. seealso::

    `PostgreSQL CREATE TABLE options
    <https://www.postgresql.org/docs/current/static/sql-createtable.html>`_ -
    in the PostgreSQL documentation.

.. _postgresql_constraint_options:

PostgreSQL Constraint Options
-----------------------------

The following option(s) are supported by the PostgreSQL dialect in conjunction
with selected constraint constructs:

* ``NOT VALID``:  This option applies towards CHECK and FOREIGN KEY constraints
  when the constraint is being added to an existing table via ALTER TABLE,
  and has the effect that existing rows are not scanned during the ALTER
  operation against the constraint being added.

  When using a SQL migration tool such as `Alembic <https://alembic.sqlalchemy.org>`_
  that renders ALTER TABLE constructs, the ``postgresql_not_valid`` argument
  may be specified as an additional keyword argument within the operation
  that creates the constraint, as in the following Alembic example::

        def update():
            op.create_foreign_key(
                "fk_user_address",
                "address",
                "user",
                ["user_id"],
                ["id"],
                postgresql_not_valid=True
            )

  The keyword is ultimately accepted directly by the
  :class:`_schema.CheckConstraint`, :class:`_schema.ForeignKeyConstraint`
  and :class:`_schema.ForeignKey` constructs; when using a tool like
  Alembic, dialect-specific keyword arguments are passed through to
  these constructs from the migration operation directives::

       CheckConstraint("some_field IS NOT NULL", postgresql_not_valid=True)

       ForeignKeyConstraint(["some_id"], ["some_table.some_id"], postgresql_not_valid=True)

  .. versionadded:: 1.4.32

  .. seealso::

      `PostgreSQL ALTER TABLE options
      <https://www.postgresql.org/docs/current/static/sql-altertable.html>`_ -
      in the PostgreSQL documentation.

.. _postgresql_table_valued_overview:

Table values, Table and Column valued functions, Row and Tuple objects
-----------------------------------------------------------------------

PostgreSQL makes great use of modern SQL forms such as table-valued functions,
tables and rows as values.   These constructs are commonly used as part
of PostgreSQL's support for complex datatypes such as JSON, ARRAY, and other
datatypes.  SQLAlchemy's SQL expression language has native support for
most table-valued and row-valued forms.

.. _postgresql_table_valued:

Table-Valued Functions
^^^^^^^^^^^^^^^^^^^^^^^

Many PostgreSQL built-in functions are intended to be used in the FROM clause
of a SELECT statement, and are capable of returning table rows or sets of table
rows. A large portion of PostgreSQL's JSON functions for example such as
``json_array_elements()``, ``json_object_keys()``, ``json_each_text()``,
``json_each()``, ``json_to_record()``, ``json_populate_recordset()`` use such
forms. These classes of SQL function calling forms in SQLAlchemy are available
using the :meth:`_functions.FunctionElement.table_valued` method in conjunction
with :class:`_functions.Function` objects generated from the :data:`_sql.func`
namespace.

Examples from PostgreSQL's reference documentation follow below:

* ``json_each()``::

    >>> from sqlalchemy import select, func
    >>> stmt = select(func.json_each('{"a":"foo", "b":"bar"}').table_valued("key", "value"))
    >>> print(stmt)
    SELECT anon_1.key, anon_1.value
    FROM json_each(:json_each_1) AS anon_1

* ``json_populate_record()``::

    >>> from sqlalchemy import select, func, literal_column
    >>> stmt = select(
    ...     func.json_populate_record(
    ...         literal_column("null::myrowtype"),
    ...         '{"a":1,"b":2}'
    ...     ).table_valued("a", "b", name="x")
    ... )
    >>> print(stmt)
    SELECT x.a, x.b
    FROM json_populate_record(null::myrowtype, :json_populate_record_1) AS x

* ``json_to_record()`` - this form uses a PostgreSQL specific form of derived
  columns in the alias, where we may make use of :func:`_sql.column` elements with
  types to produce them.  The :meth:`_functions.FunctionElement.table_valued`
  method produces  a :class:`_sql.TableValuedAlias` construct, and the method
  :meth:`_sql.TableValuedAlias.render_derived` method sets up the derived
  columns specification::

    >>> from sqlalchemy import select, func, column, Integer, Text
    >>> stmt = select(
    ...     func.json_to_record('{"a":1,"b":[1,2,3],"c":"bar"}').table_valued(
    ...         column("a", Integer), column("b", Text), column("d", Text),
    ...     ).render_derived(name="x", with_types=True)
    ... )
    >>> print(stmt)
    SELECT x.a, x.b, x.d
    FROM json_to_record(:json_to_record_1) AS x(a INTEGER, b TEXT, d TEXT)

* ``WITH ORDINALITY`` - part of the SQL standard, ``WITH ORDINALITY`` adds an
  ordinal counter to the output of a function and is accepted by a limited set
  of PostgreSQL functions including ``unnest()`` and ``generate_series()``. The
  :meth:`_functions.FunctionElement.table_valued` method accepts a keyword
  parameter ``with_ordinality`` for this purpose, which accepts the string name
  that will be applied to the "ordinality" column::

    >>> from sqlalchemy import select, func
    >>> stmt = select(
    ...     func.generate_series(4, 1, -1).
    ...     table_valued("value", with_ordinality="ordinality").
    ...     render_derived()
    ... )
    >>> print(stmt)
    SELECT anon_1.value, anon_1.ordinality
    FROM generate_series(:generate_series_1, :generate_series_2, :generate_series_3)
    WITH ORDINALITY AS anon_1(value, ordinality)

.. versionadded:: 1.4.0b2

.. seealso::

    :ref:`tutorial_functions_table_valued` - in the :ref:`unified_tutorial`

.. _postgresql_column_valued:

Column Valued Functions
^^^^^^^^^^^^^^^^^^^^^^^

Similar to the table valued function, a column valued function is present
in the FROM clause, but delivers itself to the columns clause as a single
scalar value.  PostgreSQL functions such as ``json_array_elements()``,
``unnest()`` and ``generate_series()`` may use this form. Column valued functions are available using the
:meth:`_functions.FunctionElement.column_valued` method of :class:`_functions.FunctionElement`:

* ``json_array_elements()``::

    >>> from sqlalchemy import select, func
    >>> stmt = select(func.json_array_elements('["one", "two"]').column_valued("x"))
    >>> print(stmt)
    SELECT x
    FROM json_array_elements(:json_array_elements_1) AS x

* ``unnest()`` - in order to generate a PostgreSQL ARRAY literal, the
  :func:`_postgresql.array` construct may be used::


    >>> from sqlalchemy.dialects.postgresql import array
    >>> from sqlalchemy import select, func
    >>> stmt = select(func.unnest(array([1, 2])).column_valued())
    >>> print(stmt)
    SELECT anon_1
    FROM unnest(ARRAY[%(param_1)s, %(param_2)s]) AS anon_1

  The function can of course be used against an existing table-bound column
  that's of type :class:`_types.ARRAY`::

    >>> from sqlalchemy import table, column, ARRAY, Integer
    >>> from sqlalchemy import select, func
    >>> t = table("t", column('value', ARRAY(Integer)))
    >>> stmt = select(func.unnest(t.c.value).column_valued("unnested_value"))
    >>> print(stmt)
    SELECT unnested_value
    FROM unnest(t.value) AS unnested_value

.. seealso::

    :ref:`tutorial_functions_column_valued` - in the :ref:`unified_tutorial`


Row Types
^^^^^^^^^

Built-in support for rendering a ``ROW`` may be approximated using
``func.ROW`` with the :attr:`_sa.func` namespace, or by using the
:func:`_sql.tuple_` construct::

    >>> from sqlalchemy import table, column, func, tuple_
    >>> t = table("t", column("id"), column("fk"))
    >>> stmt = t.select().where(
    ...     tuple_(t.c.id, t.c.fk) > (1,2)
    ... ).where(
    ...     func.ROW(t.c.id, t.c.fk) < func.ROW(3, 7)
    ... )
    >>> print(stmt)
    SELECT t.id, t.fk
    FROM t
    WHERE (t.id, t.fk) > (:param_1, :param_2) AND ROW(t.id, t.fk) < ROW(:ROW_1, :ROW_2)

.. seealso::

    `PostgreSQL Row Constructors
    <https://www.postgresql.org/docs/current/sql-expressions.html#SQL-SYNTAX-ROW-CONSTRUCTORS>`_

    `PostgreSQL Row Constructor Comparison
    <https://www.postgresql.org/docs/current/functions-comparisons.html#ROW-WISE-COMPARISON>`_

Table Types passed to Functions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

PostgreSQL supports passing a table as an argument to a function, which it
refers towards as a "record" type. SQLAlchemy :class:`_sql.FromClause` objects
such as :class:`_schema.Table` support this special form using the
:meth:`_sql.FromClause.table_valued` method, which is comparable to the
:meth:`_functions.FunctionElement.table_valued` method except that the collection
of columns is already established by that of the :class:`_sql.FromClause`
itself::


    >>> from sqlalchemy import table, column, func, select
    >>> a = table( "a", column("id"), column("x"), column("y"))
    >>> stmt = select(func.row_to_json(a.table_valued()))
    >>> print(stmt)
    SELECT row_to_json(a) AS row_to_json_1
    FROM a

.. versionadded:: 1.4.0b2


ARRAY Types
-----------

The PostgreSQL dialect supports arrays, both as multidimensional column types
as well as array literals:

* :class:`_postgresql.ARRAY` - ARRAY datatype

* :class:`_postgresql.array` - array literal

* :func:`_postgresql.array_agg` - ARRAY_AGG SQL function

* :class:`_postgresql.aggregate_order_by` - helper for PG's ORDER BY aggregate
  function syntax.

JSON Types
----------

The PostgreSQL dialect supports both JSON and JSONB datatypes, including
psycopg2's native support and support for all of PostgreSQL's special
operators:

* :class:`_postgresql.JSON`

* :class:`_postgresql.JSONB`

HSTORE Type
-----------

The PostgreSQL HSTORE type as well as hstore literals are supported:

* :class:`_postgresql.HSTORE` - HSTORE datatype

* :class:`_postgresql.hstore` - hstore literal

ENUM Types
----------

PostgreSQL has an independently creatable TYPE structure which is used
to implement an enumerated type.   This approach introduces significant
complexity on the SQLAlchemy side in terms of when this type should be
CREATED and DROPPED.   The type object is also an independently reflectable
entity.   The following sections should be consulted:

* :class:`_postgresql.ENUM` - DDL and typing support for ENUM.

* :meth:`.PGInspector.get_enums` - retrieve a listing of current ENUM types

* :meth:`.postgresql.ENUM.create` , :meth:`.postgresql.ENUM.drop` - individual
  CREATE and DROP commands for ENUM.

.. _postgresql_array_of_enum:

Using ENUM with ARRAY
^^^^^^^^^^^^^^^^^^^^^

The combination of ENUM and ARRAY is not directly supported by backend
DBAPIs at this time.   Prior to SQLAlchemy 1.3.17, a special workaround
was needed in order to allow this combination to work, described below.

.. versionchanged:: 1.3.17 The combination of ENUM and ARRAY is now directly
   handled by SQLAlchemy's implementation without any workarounds needed.

.. sourcecode:: python

    from sqlalchemy import TypeDecorator
    from sqlalchemy.dialects.postgresql import ARRAY

    class ArrayOfEnum(TypeDecorator):
        impl = ARRAY

        def bind_expression(self, bindvalue):
            return sa.cast(bindvalue, self)

        def result_processor(self, dialect, coltype):
            super_rp = super(ArrayOfEnum, self).result_processor(
                dialect, coltype)

            def handle_raw_string(value):
                inner = re.match(r"^{(.*)}$", value).group(1)
                return inner.split(",") if inner else []

            def process(value):
                if value is None:
                    return None
                return super_rp(handle_raw_string(value))
            return process

E.g.::

    Table(
        'mydata', metadata,
        Column('id', Integer, primary_key=True),
        Column('data', ArrayOfEnum(ENUM('a', 'b, 'c', name='myenum')))

    )

This type is not included as a built-in type as it would be incompatible
with a DBAPI that suddenly decides to support ARRAY of ENUM directly in
a new version.

.. _postgresql_array_of_json:

Using JSON/JSONB with ARRAY
^^^^^^^^^^^^^^^^^^^^^^^^^^^

Similar to using ENUM, prior to SQLAlchemy 1.3.17, for an ARRAY of JSON/JSONB
we need to render the appropriate CAST.   Current psycopg2 drivers accommodate
the result set correctly without any special steps.

.. versionchanged:: 1.3.17 The combination of JSON/JSONB and ARRAY is now
   directly handled by SQLAlchemy's implementation without any workarounds
   needed.

.. sourcecode:: python

    class CastingArray(ARRAY):
        def bind_expression(self, bindvalue):
            return sa.cast(bindvalue, self)

E.g.::

    Table(
        'mydata', metadata,
        Column('id', Integer, primary_key=True),
        Column('data', CastingArray(JSONB))
    )


i����(
tdefaultdictN(
tUUIDi
(
tarray(
tdml(
thstore(
tjson(
trangesi(
texc(
tschema(
tsql(
tutil(
tcharacteristics(
tdefault(
t
reflection(
t	coercions(
tcompiler(
telements(
t
expression(
troles(
tsqltypes(
tDDLBase(
tBIGINT(
tBOOLEAN(
tCHAR(
tDATE(
tFLOAT(
tINTEGER(
tNUMERIC(
tREAL(
tSMALLINT(
tTEXT(
tVARCHARs ^(?:btree|hash|gist|gin|[\w_]+)$ss\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|GRANT|REVOKE|IMPORT FOREIGN SCHEMA|REFRESH MATERIALIZED VIEW|TRUNCATE)talltanalysetanalyzetandtanyRtastasct
asymmetrictbothtcasetcasttchecktcollatetcolumnt
constrainttcreatetcurrent_catalogtcurrent_datetcurrent_roletcurrent_timetcurrent_timestamptcurrent_userRt
deferrabletdesctdistincttdotelsetendtexcepttfalsetfetchtfortforeigntfromtgranttgroupthavingtint	initiallyt	intersecttintotleadingtlimitt	localtimetlocaltimestamptnewtnottnulltoftofftoffsettoldtontonlytortordertplacingtprimaryt
referencest	returningtselecttsession_usertsomet	symmetricttabletthenttottrailingttruetuniontuniquetusertusingtvariadictwhentwheretwindowtwitht
authorizationtbetweentbinarytcrosstcurrent_schematfreezetfulltiliketinnertistisnulltjointlefttliketnaturaltnotnulltoutertovertoverlapstrighttsimilartverbosei�i�i�i�i�i�iiiii�i�i�tBYTEAc
BseZ
dZRS(
R�(t__name__t
__module__t__visit_name__(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�us
tDOUBLE_PRECISIONc
BseZ
dZRS(
R�(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�ys
tINETc
BseZ
dZRS(
R�(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�}s
tCIDRc
BseZ
dZRS(
R�(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
tMACADDRc
BseZ
dZRS(
R�(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
tMACADDR8c
BseZ
dZRS(
R�(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
tMONEYc
BseZ
dZd
ZRS(s�Provide the PostgreSQL MONEY type.

    Depending on driver, result rows using this type may return a
    string value which includes currency symbols.

    For this reason, it may be preferable to provide conversion to a
    numerically-based currency datatype using :class:`_types.TypeDecorator`::

        import re
        import decimal
        from sqlalchemy import TypeDecorator

        class NumericMoney(TypeDecorator):
            impl = MONEY

            def process_result_value(self, value: Any, dialect: Any) -> None:
                if value is not None:
                    # adjust this for the currency and numeric
                    m = re.match(r"\$([\d.]+)", value)
                    if m:
                        value = decimal.Decimal(m.group(1))
                return value

    Alternatively, the conversion may be applied as a CAST using
    the :meth:`_types.TypeDecorator.column_expression` method as follows::

        import decimal
        from sqlalchemy import cast
        from sqlalchemy import TypeDecorator

        class NumericMoney(TypeDecorator):
            impl = MONEY

            def column_expression(self, column: Any):
                return cast(column, Numeric())

    .. versionadded:: 1.2

    R�(R�R�t__doc__R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s(tOIDc
BseZ
dZd
ZRS(sCProvide the PostgreSQL OID type.

    .. versionadded:: 0.9.5

    R�(R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��stREGCLASSc
BseZ
dZd
ZRS(sHProvide the PostgreSQL REGCLASS type.

    .. versionadded:: 1.2.7

    R�(R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��st	TIMESTAMPcBs#eZ
dZd
Zedd�ZRS(s&Provide the PostgreSQL TIMESTAMP type.R�cCs&tt
|�jd
|
�

||_dS(s�Construct a TIMESTAMP.

        :param timezone: boolean value if timezone present, default False
        :param precision: optional integer precision value

         .. versionadded:: 1.4

        ttimezoneN(tsuperR�t__init__t	precision(tselfR�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s	
N(R�R�R�R�tFalsetNoneR�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��stTIMEcBs#eZ
dZd
Zedd�ZRS(sPostgreSQL TIME type.R�cCs&tt
|�jd
|
�

||_dS(s�Construct a TIME.

        :param timezone: boolean value if timezone present, default False
        :param precision: optional integer precision value

         .. versionadded:: 1.4

        R�N(R�R�R�R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s	
N(R�R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��stINTERVALcBskeZ
dZd
ZeZddd�Zed��
Z	e
d��
Zed�
Z
e
d��
Zd�ZRS(	sPostgreSQL INTERVAL type.R�cCs|
|_||_
d
S(s 
Construct an INTERVAL.

        :param precision: optional integer precision value
        :param fields: string fields specifier.  allows storage of fields
         to be limited, such as ``"YEAR"``, ``"MONTH"``, ``"DAY TO HOUR"``,
         etc.

         .. versionadded:: 1.2

        N(R�tfields(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�	s	
cKstd
|
j
�
S(NR�(R�tsecond_precision(tclstintervaltkw((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytadapt_emulated_to_nativesc


Cstj
S(
N(RtInterval(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_type_affinityscCstj
d
td|j�S(NtnativeR�(RR�tTrueR�(R�tallow_nulltype((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
as_generics
c


Cstj
S(
N(tdtt	timedelta(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytpython_type"sc
Cs|S(
N((R�toptvalue((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytcoerce_compared_value&s
N(R�R�R�R�R�R�R�R�tclassmethodR�tpropertyR�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�s
tBITcBseZ
dZded
�ZRS(R�cCs.|s|
pd
|_n	|
|_||_
dS(Ni
(tlengthtvarying(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�0s
	
N(R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�-s
R
cBsSeZ
dZd
Zed�
Zd�Zd�Zd�Zd�Z	e
d��
ZRS(sz
PostgreSQL UUID type.

    Represents the UUID column type, interpreting
    data either as natively returned by the DBAPI
    or as Python uuid objects.

    The UUID type is currently known to work within the prominent DBAPI
    drivers supported by SQLAlchemy including psycopg2, pg8000 and
    asyncpg. Support for other DBAPI drivers may be incomplete or non-present.

    R
cCs
|
|_d
S(s�Construct a UUID type.


        :param as_uuid=False: if True, values will be interpreted
         as Python uuid objects, converting to/from string via the
         DBAPI.

        N(
tas_uuid(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Ms	cCs3t|t
j�r|Stt|�j|
|�Sd
S(s@See :meth:`.TypeEngine.coerce_compared_value` for a description.N(t
isinstanceR
tstring_typesR�R
R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Xs
c
Cs|jrd
�}|SdSdS(Nc

Ss"|dk	rt
j|�
}n|S(
N(R�R
t	text_type(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytprocesscs


(R�R�(R�tdialectR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytbind_processor`s
		c
Cs|jrd
�}|SdSdS(Nc

Ss|dk	rt
|�
}n|S(
N(R�t_python_UUID(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�os


(R�R�(R�R�tcoltypeR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytresult_processorls
		c
Cs'|jrd
�}|Sd�}|SdS(Nc

Ss|dk	rd
|}n|S(Ns
'%s'::UUID(
R�(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�{s



c

Ss|dk	rd
|}n|S(Ns'%s'(
R�(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s



(
R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytliteral_processorxs

			c


Cs|jr
t
StS(
N(R�R�tstr(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s(R�R�R�R�R�R�R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR
=s				tTSVECTORc
BseZ
dZd
ZRS(s
The :class:`_postgresql.TSVECTOR` type implements the PostgreSQL
    text search type TSVECTOR.

    It can be used to do full text queries on natural language
    documents.

    .. versionadded:: 0.9.0

    .. seealso::

        :ref:`postgresql_match`

    R�(R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��stENUMcBs�eZ
dZeZd
�Zed��
Zded�Z	ded�Z
def
d��YZdef
d��YZ
d	�Zed
�
Zed�
Zed�
Zed
�
ZRS(s�PostgreSQL ENUM type.

    This is a subclass of :class:`_types.Enum` which includes
    support for PG's ``CREATE TYPE`` and ``DROP TYPE``.

    When the builtin type :class:`_types.Enum` is used and the
    :paramref:`.Enum.native_enum` flag is left at its default of
    True, the PostgreSQL backend will use a :class:`_postgresql.ENUM`
    type as the implementation, so the special create/drop rules
    will be used.

    The create/drop behavior of ENUM is necessarily intricate, due to the
    awkward relationship the ENUM type has in relationship to the
    parent table, in that it may be "owned" by just a single table, or
    may be shared among many tables.

    When using :class:`_types.Enum` or :class:`_postgresql.ENUM`
    in an "inline" fashion, the ``CREATE TYPE`` and ``DROP TYPE`` is emitted
    corresponding to when the :meth:`_schema.Table.create` and
    :meth:`_schema.Table.drop`
    methods are called::

        table = Table('sometable', metadata,
            Column('some_enum', ENUM('a', 'b', 'c', name='myenum'))
        )

        table.create(engine)  # will emit CREATE ENUM and CREATE TABLE
        table.drop(engine)  # will emit DROP TABLE and DROP ENUM

    To use a common enumerated type between multiple tables, the best
    practice is to declare the :class:`_types.Enum` or
    :class:`_postgresql.ENUM` independently, and associate it with the
    :class:`_schema.MetaData` object itself::

        my_enum = ENUM('a', 'b', 'c', name='myenum', metadata=metadata)

        t1 = Table('sometable_one', metadata,
            Column('some_enum', myenum)
        )

        t2 = Table('sometable_two', metadata,
            Column('some_enum', myenum)
        )

    When this pattern is used, care must still be taken at the level
    of individual table creates.  Emitting CREATE TABLE without also
    specifying ``checkfirst=True`` will still cause issues::

        t1.create(engine) # will fail: no such type 'myenum'

    If we specify ``checkfirst=True``, the individual table-level create
    operation will check for the ``ENUM`` and create if not exists::

        # will check if enum exists, and emit CREATE TYPE if not
        t1.create(engine, checkfirst=True)

    When using a metadata-level ENUM type, the type will always be created
    and dropped if either the metadata-wide create/drop is called::

        metadata.create_all(engine)  # will emit CREATE TYPE
        metadata.drop_all(engine)  # will emit DROP TYPE

    The type can also be created and dropped directly::

        my_enum.create(engine)
        my_enum.drop(engine)

    .. versionchanged:: 1.0.0 The PostgreSQL :class:`_postgresql.ENUM` type
       now behaves more strictly with regards to CREATE/DROP.  A metadata-level
       ENUM type will only be created and dropped at the metadata level,
       not the table level, with the exception of
       ``table.create(checkfirst=True)``.
       The ``table.drop()`` call will now emit a DROP TYPE for a table-level
       enumerated type.

    c
Os`|jd
d�}|tkr.tjd�

n|jdt�|_tt|�j	|
|�
dS(sConstruct an :class:`_postgresql.ENUM`.

        Arguments are the same as that of
        :class:`_types.Enum`, but also including
        the following parameters.

        :param create_type: Defaults to True.
         Indicates that ``CREATE TYPE`` should be
         emitted, after optionally checking for the
         presence of the type, when the parent
         table is being created; and additionally
         that ``DROP TYPE`` is called when the table
         is dropped.    When ``False``, no check
         will be performed and no ``CREATE TYPE``
         or ``DROP TYPE`` is emitted, unless
         :meth:`~.postgresql.ENUM.create`
         or :meth:`~.postgresql.ENUM.drop`
         are called directly.
         Setting to ``False`` is helpful
         when invoking a creation scheme to a SQL file
         without access to the actual database -
         the :meth:`~.postgresql.ENUM.create` and
         :meth:`~.postgresql.ENUM.drop` methods can
         be used to emit SQL to a target bind.

        tnative_enums�the native_enum flag does not apply to the sqlalchemy.dialects.postgresql.ENUM datatype; this type always refers to ENUM.   Use sqlalchemy.types.Enum for non-native enum.tcreate_typeN(
tpopR�R�R
twarnR�R�R�R�R�(R�tenumsR�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s




cKs�|jd
|
j
�
|jd|
j�
|jd|
j�
|jd|
j�
|jd|
j�
|jdt�
|jd|
j�
|jd|
j�
||�S(	sbProduce a PostgreSQL native :class:`_postgresql.ENUM` from plain
        :class:`.Enum`.

        tvalidate_stringstnameRtinherit_schematmetadatat_create_eventstvalues_callabletomit_aliases(	t
setdefaultR�R�RR�R�R�R�t
_omit_aliases(R�timplR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�s







cCs-|
jj
sd
S|
j|j|d|�

d
S(s�
Emit ``CREATE TYPE`` for this
        :class:`_postgresql.ENUM`.

        If the underlying dialect does not support
        PostgreSQL CREATE TYPE, no action is taken.

        :param bind: a connectable :class:`_engine.Engine`,
         :class:`_engine.Connection`, or similar object to emit
         SQL.
        :param checkfirst: if ``True``, a query against
         the PG catalog will be first performed to see
         if the type does not exist already before
         creating.

        Nt
checkfirst(R�tsupports_native_enumt_run_ddl_visitort
EnumGenerator(R�tbindR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR/,s
cCs-|
jj
sd
S|
j|j|d|�

d
S(s�
Emit ``DROP TYPE`` for this
        :class:`_postgresql.ENUM`.

        If the underlying dialect does not support
        PostgreSQL DROP TYPE, no action is taken.

        :param bind: a connectable :class:`_engine.Engine`,
         :class:`_engine.Connection`, or similar object to emit
         SQL.
        :param checkfirst: if ``True``, a query against
         the PG catalog will be first performed to see
         if the type actually exists before dropping.

        NR�(R�R�R�tEnumDropper(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdropAs
R�cBs&eZ
ed�
Zd
�Zd�ZRS(cKs)tt
j|�j||�

||_dS(
N(R�R�R�R�R�(R�R�t
connectionR�tkwargs((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Vs

cCsB|js
t
S|jj|
�
}|jjj|j|
jd
|�
S(NR(R�R�R�tschema_for_objectR�thas_typeR�(R�tenumteffective_schema((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_can_create_enumZs

	

cCs-|j|
�
sdS|j
jt|
�
�

dS(
N(R�R�texecutetCreateEnumType(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_enumds

(R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Us
	
R�cBs&eZ
ed�
Zd
�Zd�ZRS(cKs)tt
j|�j||�

||_dS(
N(R�R�R�R�R�(R�R�R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�ks

cCsA|js
t
S|jj|
�
}|jjj|j|
jd
|�
S(NR(R�R�R�R�R�R�R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_can_drop_enumos

	

cCs-|j|
�
sdS|j
jt|
�
�

dS(
N(R�R�R�tDropEnumType(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�ys

(R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�js
	
cCs�|js
t
Sd
|kr�|d
}d|jkrB|jd}nt�}|jd<|j|jf|k}|j|j|jf�

|StSdS(s
Look in the 'ddl runner' for 'memos', then
        note our name in that collection.

        This to ensure a particular named enum is operated
        upon only once within any kind of create/drop
        sequence without relying upon "checkfirst".

        t_ddl_runnert	_pg_enumsN(R�R�tmemotsetRR�taddR�(R�R�R�t
ddl_runnertpg_enumstpresent((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_check_for_name_in_memoss		








cKsS|s#|jrO|j
d
t�rO|j||�rO|jd|d|�
ndS(Nt_is_metadata_operationR�R�(R�tgetR�R�R/(R�ttargetR�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_table_create�s



cKsM|jrI|j
d
t�rI|j||�rI|jd|d|�
ndS(NR�R�R�(R�R�R�R�R�(R�R�R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_table_drop�s


cKs/|j||�s+|j
d
|d|�
ndS(NR�R�(R�R/(R�R�R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_metadata_create�s

cKs/|j||�s+|j
d
|d|�
ndS(NR�R�(R�R�(R�R�R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_metadata_drop�s

N(R�R�R�R�R�R�R�R�R�R/R�RR�R�R�R�R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��sM	&	
t
_ColonCastc
BseZ
dZd
�ZRS(t
colon_castcCs(||_|
|_
tj|�
|_dS(
N(ttypetclauseRt
TypeClauset
typeclause(R�Rttype_((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
	
	
(R�R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
t_arrayRRtjsonbt	int4ranget	int8rangetnumranget	daterangettsranget	tstzrangetintegertbiginttsmallintscharacter varyingt	characters"char"R�ttexttnumerictfloattrealtinettcidrtuuidtbitsbit varyingtmacaddrtmacaddr8tmoneytoidtregclasssdouble precisiont	timestampstimestamp with time zonestimestamp without time zonestime with time zonestime without time zonetdatettimetbyteatbooleanR�ttsvectort
PGCompilercBs%
eZ
d�Zd
�Zd�Zed�
Zed�
Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zejd��
Zd�Zd�Zd�Z d�Z!d�Z"RS(cKs,d
|
jj
||�
|
jj
||�
fS(Ns%s::%s(R�t_compiler_dispatchR�(R�telementR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_colon_cast�s


cKsd
|j|
|�
S(Ns	ARRAY[%s](
tvisit_clauselist(R�R
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_array�s
cKs,d
|j|
j
|�
|j|
j|�
fS(Ns%s:%s(R�tstarttstop(R�R
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_slice�s


cKsn|rE|
jj
tjk	rEt|d
<|jtj|
|
j�|�
St|d<|j|
|sddnd|�S(Nt
_cast_appliedteager_groupings -> s ->> (	R�R�RtJSONR�R�R	R*t_generate_generic_binary(R�RptoperatorR!
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_json_getitem_op_binary	s




cKsn|rE|
jj
tjk	rEt|d
<|jtj|
|
j�|�
St|d<|j|
|sddnd|�S(NR!
R"
s #> s #>> (	R�R�RR#
R�R�R	R*R$
(R�RpR%
R!
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt!visit_json_path_getitem_op_binary	s





cKs,d
|j|
j
|�
|j|
j|�
fS(Ns%s[%s](R�RzR�(R�RpR%
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_getitem_binary!	s


cKs,d
|j|
j
|�
|j|
j|�
fS(Ns%s ORDER BY %s(R�R�torder_by(R�R
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_aggregate_order_by'	s


cKs�d
|
jkrc|j
|
jd
tj�}|rcd|j|
j|�
||j|
j|�
fSnd|j|
j|�
|j|
j|�
fS(Ntpostgresql_regconfigs%s @@ to_tsquery(%s, %s)s%s @@ to_tsquery(%s)(t	modifierstrender_literal_valueRt
STRINGTYPER�RzR�(R�RpR%
R�t	regconfig((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_match_op_binary-	s








cKsd|
jj
d
d�}d|j|
j|�
|j|
j|�
f|r_d|j|tj�ndS(Ntescapes%s ILIKE %ss ESCAPE t(	R,
R�R�R�RzR�R-
RR.
(R�RpR%
R�R1
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_ilike_op_binary=	s



cKsd|
jj
d
d�}d|j|
j|�
|j|
j|�
f|r_d|j|tj�ndS(NR1
s%s NOT ILIKE %ss ESCAPE R2
(	R,
R�R�R�RzR�R-
RR.
(R�RpR%
R�R1
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_not_ilike_op_binaryI	s




cCs�|jd
}|dkr0|j|d|
|�S|dkrS|j|d|
|�Sd|j|j|�
|
|j|tj�|j|j|�
fS(Ntflagss %s t
is %s* s%s %s CONCAT('(?', %s, ')', %s)(	R,
R�R$
R�RzR-
RR.
R�(R�tbase_opRpR%
R�R5
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
_regexp_matchT	s










cKs|jd
|
||�S(Nt
~(
R8
(R�RpR%
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_regexp_match_op_binarye	s
cKs|jd
|
||�S(Ns!~(
R8
(R�RpR%
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_not_regexp_match_op_binaryh	s
cKsu|j|
j
|�
}|j|
j|�
}|
jd
}|dkrQd||fSd|||j|tj�fSdS(NR5
sREGEXP_REPLACE(%s, %s)sREGEXP_REPLACE(%s, %s, %s)(R�RzR�R,
R�R-
RR.
(R�RpR%
R�tstringtpattern_replaceR5
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_regexp_replace_op_binaryk	s










cs0d
dj�f
d�|
p$t
�g
D�
�
f
S(NsSELECT %s WHERE 1!=1s, c
3s:|]0}
d�jj
j|
jr*t�n|
�
V
qd
S(sCAST(NULL AS %s)N(R�t
type_compilerR�t_isnullR(t.0R�(
R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�	s(RyR(R�t
element_types((
R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_empty_set_expr{	s

cCs@tt
|�j|
|�}
|jjr<|
jd
d�}
n|
S(Ns
\s\\(R�R
R-
R�t_backslash_escapestreplace(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR-
�	s


cKsd
|jj
|
�
S(Ns
nextval('%s')(tpreparertformat_sequence(R�tseqR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_sequence�	s
cKs�d
}|
jdk	r5|d|j|
j|�
7}n|
jdk	r�|
jdkr`|d7}n|d|j|
j|�
7}n|S(NR2
s	 
 LIMIT s
 LIMIT ALLs OFFSET (t
_limit_clauseR�R�t_offset_clause(R�R\R�R
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytlimit_clause�	s


 




 
cCs0|j�d
kr(t
jd|�
�
nd|
S(NtONLYsUnrecognized hint: %rsONLY (tupperRtCompileError(R�tsqltextR`thinttiscrud((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytformat_from_hint_text�	s


cKsa|
js|
j
rY|
j
rRd
djg|
j
D]}|j||�
^q.�
dSdSndSdS(Ns
DISTINCT ON (s, s) s	DISTINCT R2
(t	_distinctt_distinct_onRyR�(R�R\R�tcol((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_select_precolumns�	s

		7cs�|
jj
r*|
jjr!d
}qEd}n|
jjr?d}nd}|
jjr�tj�}x*|
jjD]}|jtj|�
�

qjW|ddj	��
fd�|D�
�
7}n|
jj
r�|d7}n|
jjr�|d	7}n|S(
Ns FOR KEY SHAREs
 FOR SHAREs FOR NO KEY UPDATEs FOR UPDATEs OF s, c
3s-|]#}
�
j|
dt
d
t��
V
qdS(tashintt
use_schemaN(R�R�R�(RA
R`(R�R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�	s
s NOWAITs SKIP LOCKED(t_for_update_argtreadt	key_shareRPR
t
OrderedSettupdatetsql_utiltsurface_selectables_onlyRytnowaittskip_locked(R�R\R�ttmpttablest
c((R�R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytfor_update_clause�	s&

		

	








cCsHgtj
|�
D]!}|j|
|d
|j�
^q}ddj|�
S(Ntfallback_label_names
RETURNING s, (Rt_select_iterablest_label_returning_columnt_non_anon_labelRy(R�tstmttreturning_colsRe
tcolumns((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytreturning_clause�	s4cKs�|j|
j
j
d
|�
}|j|
j
j
d|�
}t|
j
j
�
dkr}|j|
j
j
d|�
}d|||fSd||fSdS(Nii
isSUBSTRING(%s FROM %s FOR %s)sSUBSTRING(%s FROM %s)(R�tclausestlen(R�tfuncR�t
sR
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_substring_func�	s




cs�|
jdk	r+d
�jj|
j�
}nv|
jdk	r�ddj�f
d�|
jD�
�
}|
jdk	r�|d�j|
jdtdt�
7}q�nd}|S(	NsON CONSTRAINT %ss(%s)s, c
3sN|]D}
t|
t
j�r-�jj|
�
n�j|
dtd
t�
V
qdS(t
include_tableRY
N(R�R
R�RF
tquoteR�R�(RA
Re
(
R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�	ss	 WHERE %sRt
RY
R2
(	tconstraint_targetR�RF
t#truncate_and_render_constraint_nametinferred_target_elementsRytinferred_target_whereclauseR�R�(R�R�R�ttarget_text((
R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_conflict_target�	s
	

	


	

c

Cs7|jdk	o6|jjdkp6t|jjtj�S(
N(tinsert_single_values_exprR�t	statementt_post_values_clauseR�RtOnConflictDoNothing(
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt&_is_safe_for_fast_insert_values_helper

s


cKs(|j|
|�
}|r d
|SdSdS(NsON CONFLICT %s DO NOTHINGsON CONFLICT DO NOTHING(
R{
(R�ton_conflictR�Rz
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_on_conflict_do_nothing
s
cKsr|
}|j|
|�
}g}t
|j�
}|jd
d}|jj}x
|D]�}	|	j}
|
|kr~|j|
�
}n!|	|krQ|j|	�
}nqQtj	|�
r�t
jd|d|	j
�
}n9t|t
j�r
|j
jr
|j�}|	j
|_
n|j|j�dt�

}|jj|	j�
}
|jd|
|f�

qQW|rtjd|jjjdjd�|D�
�
f�

x�|j�D]�\}}t|tj�r�
|jj|�
n|j|dt�

}
|jtjtj |�dt�

}|jd|
|f�

q�
Wndj|�
}|j!dk	rd|d	|j|j!d
t"dt�
7}nd||fS(Ni����t
selectableR�RY
s%s = %ssFAdditional column names not matching any column keys in table '%s': %ss, c
ss|]}
d|
V
qd
S(s'%s'N((RA
Re
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>R
ss	 WHERE %sRt
sON CONFLICT %s DO UPDATE SET %s(#R{
tdicttupdate_values_to_settstackR`Re
tkeyR�Rt_is_literalRt
BindParameterR�R�R�R@
t_cloneR�t
self_groupR�RF
Ru
R�tappendR
R�tcurrent_executableRytitemsR�texpectRtExpressionElementRoletupdate_whereclauseR�(R�R�
R�R�Rz
taction_set_opstset_parameterstinsert_statementtcolsRe
tcol_keyR�t
value_texttkey_textt
kt
vtaction_text((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_on_conflict_do_update%
sN



	










$


	


cs1t�
d
<ddj
��
�fd�|D�
�
S(NtasfromsFROM s, c
3s'|]}
|
j�d��
�

V
qd
S(t	fromhintsN(
R
(RA
t
t(t
from_hintsR�R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>n
s
(R�Ry(R�tupdate_stmtt
from_tabletextra_fromsR�
R�((R�
R�R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytupdate_from_clausei
s

	

cs1t�
d
<ddj
��
�fd�|D�
�
S(s9Render the DELETE .. USING clause specific to PostgreSQL.R�
sUSING s, c
3s'|]}
|
j�d��
�

V
qd
S(R�
N(
R
(RA
R�
(R�
R�R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>x
s
(R�Ry(R�tdelete_stmtR�
R�
R�
R�((R�
R�R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdelete_extra_from_clauser
s

	

cKs�d
}|
jdk	r5|d|j|
j|�
7}n|
jdk	r�|d|j|
j|�
|
jdrodnd
|
jdr�dndf7}n|S(	NR2
s
 OFFSET (%s) ROWSs
 FETCH FIRST (%s)%s ROWS %stpercents PERCENTt	with_tiess	WITH TIESRM
(RK
R�R�t
_fetch_clauset_fetch_clause_options(R�R\R�R
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytfetch_clause|
s






(#R�R�R
R
R 
R�R&
R'
R(
R*
R0
R3
R4
R8
R:
R;
R>
RC
R-
RI
RL
RS
RW
Rf
Rn
Rs
R{
R
tmemoized_propertyR�
R�
R�
R�
R�
R�
(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR
�s<
																
							"			D			
t
PGDDLCompilerc
Bs}eZ
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�ZRS(
cKs|jj
|
�
}|
jj|j�
}t|tj�rE|j}n|
j	dk	o]|jj}|
jr
|
|
j
jkr
|jjs�t|tj�r
|r
|
jdks�t|
jtj�r
|
jjr
t|tj�r�|d
7}qw
t|tj�r
|d7}qw
|d7}n[|d|jjj|
jd|
d|j�
7}|j|
�
}|dk	rw
|d|7}n|
jdk	r�
|d|j|
j�
7}n|r�
|d|j|
j	�
7}n|
jr�
|r�
|d7}n|
jr|r|d	7}n|S(
Ns
 BIGSERIALs SMALLSERIALs SERIALt
 ttype_expressiontidentifier_preparers	 DEFAULT s	 NOT NULLs NULL(RF
t
format_columnR�tdialect_implR�R�Rt
TypeDecoratorR�tidentityR�tsupports_identity_columnstprimary_keyR`t_autoincrement_columntsupports_smallserialtSmallIntegerRRtSequencetoptionalt
BigIntegerR?
R�tget_column_default_stringtcomputedtnullable(R�R-R�tcolspect	impl_typethas_identityR((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_column_specification�
sF



	









	












cCs|
jd
d}|rdSdS(Nt
postgresqlt	not_valids
 NOT VALIDR2
(
tdialect_options(R�R.R�
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_define_constraint_validity�
s

cCs�|
jrht
|
j�
d
j}t|tj�rht|jtj�rh|jj	rht
jd�
�
qhntt
|�j|
�
}||j|
�
7}|S(Nis�PostgreSQL dialect cannot produce the CHECK constraint for ARRAY of non-native ENUM; please specify create_constraint=False on this Enum datatype.(t_type_boundtlistRm
R�R�RtARRAYt	item_typetEnumR�RRO
R�R�
tvisit_check_constraintR�
(R�R.ttypR
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�
�
s
	






cCs/tt
|�j|
�
}||j|
�
7}|S(
N(R�R�
tvisit_foreign_key_constraintR�
(R�R.R
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�
�
s

	
cCsd
|jj
|
j�
S(NsCOMMENT ON TABLE %s IS NULL(RF
tformat_tableR
(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_drop_table_comment�
s

cs?|
j}d
�j
j|�
dj�f
d�|jD�
�
fS(NsCREATE TYPE %s AS ENUM (%s)s, c
3s0|]&}
�jj
tj|
�
dt�

V
qd
S(t
literal_bindsN(tsql_compilerR�R	tliteralR�(RA
t
e(
R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�
s
(R
RF
tformat_typeRyR�(R�R/R�((
R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_create_enum_type�
s
	



cCs|
j}d
|j
j|�
S(NsDROP TYPE %s(R
RF
R�
(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_drop_enum_type�
s
	cCs|j}|
j
}|j|�

d
}|jr;|d7}n|d7}|jjrx|jdd}|rx|d7}qxn|
jr�|d7}n|d|j|d	t	�

|j
|j�
f7}|jdd
}|r�|d|jj|t
�j�7}n|jdd}|d
djg|jD]u}|jjt|tj�sN
|j�n|dt	dt�
t|d�r�
|j|kr�
d||jnd^q!
�
7}|jdd}	|	r,g|	D].}
t|
tj�r�
|jj|
n|
^q�
}|ddjg|D]}|j|j�
^q�
7}n|jdd}
|
rz|ddjg|
j�D]}d|^q\�
7}n|jdd}|r�|d|j|�
7}n|jdd}|dk	rt!j"t#j$|�}|jj|dt	dt�
}|d|7}n|S(NsCREATE sUNIQUE sINDEX R�
tconcurrentlys
CONCURRENTLY sIF NOT EXISTS s	%s ON %s tinclude_schemaRhs	USING %s topss(%s)s, Rt
R�
R�
R�
R2
tincludes
 INCLUDE (%s)Rms
 WITH (%s)s%s = %st
tablespaces TABLESPACE %sRks WHERE (%RF
R
t_verify_index_tableRfR�t#_supports_create_index_concurrentlyR�
t
if_not_existst_prepared_index_nameR�R�
R`tvalidate_sql_phraset	IDX_USINGtlowerRytexpressionsR�
R�R�RtColumnClauseR�
R�thasattrR�
R
R�Re
Ru
R�R�
R�RR�
RtDDLExpressionRole(R�R/RF
tindexR
R�
RhR�
texprt
includeclauseRV
t
inclusionsRe
t
withclausetstorage_parameterttablespace_nametwhereclausetwhere_compiled((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_create_index�
sb
	
	



	






	







 

�
8
-



(




	
cCsu|
j}d
}|j
jrB|jdd}|rB|d7}qBn|
jrX|d7}n||j|dt�

7}|S(Ns
DROP INDEX R�
R�
s
CONCURRENTLY s
IF EXISTS R�
(R
R�t!_supports_drop_index_concurrentlyR�
t	if_existsR�
R�(R�R�R�
R
R�
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_drop_indexTs
	


	


c	KsE
d
}|
jdk	r2|d|jj|
�
7}ng}x�|
jD]~\}}}t|d<|jj||�
t|d�r�|j	|
j
kr�d|
j
|j	nd
}|jd||f�

qBW|d|jj|
j
t�j�dj|�
f7}|
jdk	r.
|d	|jj|
jd
t�

7}n||j|
�
7}|S(NR2
sCONSTRAINT %s Rt
R�
R�
s
%s WITH %ssEXCLUDE USING %s (%s)s, s WHERE (%s)R�
(R�R�RF
tformat_constraintt
_render_exprsR�R�
R�R�
R�
R�
R�
R�
RhR�
R�
RyRkR�tdefine_constraint_deferrability(	R�R.R�R
RR�
R�R�texclude_element((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_exclude_constraintds(







5


	



cs]
g}|
jd
}|j
d�
}|dk	r�t|ttf�sO|f
}n|jddj�f
d�|D�
�
d�

n|dr�|jd|d�

n|d	tkr�|jd
�

n |d	t	kr�|jd�

n|dr
|dj
d
d�j�}|jd|�

n|drP
|d}|jd�jj
|�
�

ndj|�
S(NR�
tinheritss

 INHERITS ( s, c
3s!|]}
�jj
|
�
V
qdS(
N(RF
Ru
(RA
R�(
R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�ss )tpartition_bys
 PARTITION BY %st	with_oidss
 WITH OIDSs
 WITHOUT OIDSt	on_committ
_R�
s
 ON COMMIT %sR�
s
 TABLESPACE %sR2
(R�
R�R�R�R�
ttupleR�
RyR�R�RE
RN
RF
Ru
(R�R`t
table_optstpg_optsR�
ton_commit_optionsR�
((
R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytpost_create_table�s,






+












cCsD|
jt
kr!tjd
�
�
nd|jj|
jdt
dt�
S(Ns�PostrgreSQL computed columns do not support 'virtual' persistence; set the 'persisted' flag to None or True for PostgreSQL support.sGENERATED ALWAYS AS (%s) STOREDRt
R�
(t	persistedR�RRO
R�
R�RP
R�(R�t	generated((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_computed_column�s




cKsVd}|
j
jdk	r7d
|jj|
j
j�
}ntt|�j|
d||�

S(Ns AS %stprefix(R�R
t	data_typeR?
R�R�R�
tvisit_create_sequence(R�R/R�R((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR
�s




(R�R�R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
RRR
(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�
�
s
	7							Z			"	tPGTypeCompilercBs"
eZ
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zdd�
Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!RS( c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_TSVECTOR�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_INET�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_CIDR�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_MACADDR�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_MACADDR8�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_MONEY�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt	visit_OID�s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_REGCLASS�s
cKs#|
js
d
Sdi
|
jd6SdS(NRsFLOAT(%(precision)s)R�(
R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_FLOAT�s
	
c
Ksd
S(NsDOUBLE PRECISION((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_DOUBLE_PRECISION�s
c
Ksd
S(NR((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_BIGINT�s
c
Ksd
S(NtHSTORE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_HSTORE�s
c
Ksd
S(NR#
((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_JSON�s
c
Ksd
S(NtJSONB((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_JSONB�s
c
Ksd
S(Nt	INT4RANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INT4RANGE�s
c
Ksd
S(Nt	INT8RANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INT8RANGE�s
c
Ksd
S(NtNUMRANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_NUMRANGE�s
c
Ksd
S(Nt	DATERANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_DATERANGE�s
c
Ksd
S(NtTSRANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_TSRANGE�s
c
Ksd
S(Nt	TSTZRANGE((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_TSTZRANGE�s
cKs|j|
|�
S(
N(
tvisit_TIMESTAMP(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_datetime�s
cKsD|
js|j
jr0tt|�j|
|�
S|j|
|�
SdS(
N(R�R�R�R�RR�t
visit_ENUM(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s

cKs(|dkr|j
j}n|j|
�
S(
N(R�R�R�
R�
(R�R�R�
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR*s


cKsFd
t|
dd�dk	r(d|
jnd|
jr:dp=ddfS(NsTIMESTAMP%s %sR�s(%d)R2
tWITHtWITHOUTs
 TIME ZONE(tgetattrR�R�R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR(	s
%

cKsFd
t|
dd�dk	r(d|
jnd|
jr:dp=ddfS(Ns	TIME%s %sR�s(%d)R2
R+R,s
 TIME ZONE(R-R�R�R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_TIMEs
%

cKsPd
}|
jdk	r)|d|
j7}n|
jdk	rL|d|
j7}n|S(NR�R�
s (%d)(R�R�R�(R�R�R�R
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INTERVALs





cKsF|
jr5d
}|
j
dk	rB|d|
j
7}qBn
d|
j
}|S(NsBIT VARYINGs(%d)sBIT(%d)(R�R�R�(R�R�R�tcompiled((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt	visit_BIT!s
	




c
Ksd
S(NR
((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_UUID*s
cKs|j|
|�
S(
N(
tvisit_BYTEA(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_large_binary-s
c
Ksd
S(NR�((R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR30s
cKsN|j|
j
|�
}tjd
dd|
jdk	r<|
jnd|dd�
S(Ns((?: COLLATE.*)?)$s%s\1s[]i
tcount(R�R�
tretsubt
dimensionsR�(R�R�R�Rv((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_ARRAY3s



N("R�R�RR
RRRRRRRRRRRRRRR!R#R%R'R)R�R�R*R(R.R/R1R2R4R3R9(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�s>
																														tPGIdentifierPreparercBs#eZ
eZd�Zed
�
ZRS(cCs9|
d
|jkr5|
dd!j
|j|j�}
n|
S(Nii
i����(t
initial_quoteRE
tescape_to_quotetescape_quote(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_unquote_identifierHs



cCsv|
jst
jd
�
�
n|j|
j�
}|j|
�
}|jrr|rr|dk	rr|j|�
d|}n|S(Ns%PostgreSQL ENUM type requires a name.t
.(R�RRO
Ru
R�tomit_schemaR�tquote_schema(R�R�RY
R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�
Os
	





(R�R�tRESERVED_WORDStreserved_wordsR>R�R�
(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR:Ds	tPGInspectorcBs;eZ
dd�
Zdd
�
Zdd�
Zddd�ZRS(c
Cs8|j��&}|j
j||
|d
|j�
SWdQXdS(s(Return the OID for the given table name.t
info_cacheN(t_operation_contextR�t
get_table_oidRE(R�t
table_nameRtconn((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRG`s
	
cCs;|
p|j}
|j
��}|jj||
�SWd
QXd
S(sKReturn a list of ENUM objects.

        Each member is a dictionary containing these fields:

            * name - name of the enum
            * schema - the schema name for the enum.
            * visible - boolean, whether or not this enum is visible
              in the default search path.
            * labels - a list of string labels that apply to the enum.

        :param schema: schema name.  If None, the default schema
         (typically 'public') is used.  May also be set to '*' to
         indicate load enums for all schemas.

        .. versionadded:: 1.0.0

        N(tdefault_schema_nameRFR�t_load_enums(R�RRI((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt	get_enumshs

cCs;|
p|j}
|j
��}|jj||
�SWd
QXd
S(s
Return a list of FOREIGN TABLE names.

        Behavior is similar to that of
        :meth:`_reflection.Inspector.get_table_names`,
        except that the list is limited to those tables that report a
        ``relkind`` value of ``f``.

        .. versionadded:: 1.0.0

        N(RJRFR�t_get_foreign_table_names(R�RRI((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_foreign_table_names~s

tplaintmaterializedcCs;|j��)}|j
j||
d
|jd|�SWdQXdS(s�
Return all view names in `schema`.

        :param schema: Optional, retrieve names from a non-default schema.
         For special quoting, use :class:`.quoted_name`.

        :param include: specify which types of views to return.  Passed
         as a string value (for a single type) or a tuple (for any number
         of types).  Defaults to ``('plain', 'materialized')``.

         .. versionadded:: 1.1

        RER�
N(RFR�tget_view_namesRE(R�RR�
RI((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRQ�s
	
N(RORP(R�R�R�RGRLRNRQ(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRD_s
R�c
BseZ
dZRS(
tcreate_enum_type(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
R�c
BseZ
dZRS(
tdrop_enum_type(R�R�R�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
tPGExecutionContextc
Bs#eZ
d�Zd
�Zd�ZRS(cCs |jd
|j
j|
�
|�S(Nsselect nextval('%s')(t_execute_scalarR�
RG
(R�RH
R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
fire_sequence�s

cCs�
|
jr~
|
|
j
jkr~
|
jrM|
jjrM|jd
|
jj|
j�S|
jdkst|
jj
r~
|
jjr~
y
|
j}Wn�t
k
r



|
j
j}|
j}|ddtddt|�
�!}|ddtddt|�
�!}d||f}||
_}n
X|
j
dk	r6
|jj|
j
�
}nd}|dk	r[
d||f}n
d|f
}|j||
j�Sntt|�j|
�
S(Ns	select %siis	%s_%s_seqsselect nextval('"%s"."%s"')sselect nextval('"%s"')(R�
R`R�
tserver_defaultthas_argumentRUtargR�RR�tis_sequenceR�
t_postgresql_seq_nametAttributeErrorR�tmaxRp
R�R�R�RTtget_insert_default(R�R-tseq_namettabRV
R�R�R((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR^�s4









	
$
$


	





cCs
tj
|
�
S(
N(tAUTOCOMMIT_REGEXPtmatch(R�R}
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytshould_autocommit_text�s
(R�R�RVR^Rc(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRT�s
			-t"PGReadOnlyConnectionCharacteristicc
Bs)eZ
eZd�Zd
�Zd�ZRS(cCs|
j|t
�
dS(
N(tset_readonlyR�(R�R�t
dbapi_conn((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytreset_characteristic�s
cCs|
j||�
dS(
N(
Re(R�R�RfR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytset_characteristic�s
cCs
|
j|�
S(
N(
tget_readonly(R�R�Rf((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_characteristic�s
(R�R�R�t
transactionalRgRhRj(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRd�s		t$PGDeferrableConnectionCharacteristicc
Bs)eZ
eZd�Zd
�Zd�ZRS(cCs|
j|t
�
dS(
N(tset_deferrableR�(R�R�Rf((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRg�s
cCs|
j||�
dS(
N(
Rm(R�R�RfR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRh�s
cCs
|
j|�
S(
N(
tget_deferrable(R�R�Rf((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRj�s
(R�R�R�RkRgRhRj(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRl�s		t	PGDialectcBs�eZ
dZeZeZd
ZeZeZeZ	eZ
eZeZeZ
eZeZeZeZeZeZeZdZeZeZeZeZeZeZ e!Z"e#Z$d?Z&eZ'eZ(e)j*j+Z+e+j,ie-�d6e.�d6�
Z+e/j0ied6d?d6d?d6id6ed	6id
6d?d6fe/j1ied6d?d6d?d
6d?d6d?d6d?d6fe/j2i
ed6fe/j3i
ed6fgZ4d@Z5eZ6eZ7eZ8d?d?d?d�Z9d�Z:d�Z;e<ddddg�
Z=d�Z>d�Z?d�Z@d�ZAd�ZBd�ZCd �ZDd!�ZEeed"�ZFeed#�ZGd$�ZHd%�ZId&�ZJd?d'�
ZKd?d(�
ZLd?d)�
ZMd*�ZNeOjPd?d+�
�
ZQeOjPd,��
ZReOjPd?d-�
�
ZSeOjPd?d.�
�
ZTeOjPd?dAd1��
ZUeOjPd?d2�
�
ZVeOjPd?d3�
�
ZWeOjPd?d4�
�
ZXd5�ZYeOjPd?d6�
�
ZZeOjPd?ed7��
Z[d8�Z\eOjPd9��
Z]eOjPd?d:�
�
Z^eOjPd?d;�
�
Z_eOjPd?d<�
�
Z`d?d=�
Zad>�ZbRS(BR�
i?tpyformattpostgresql_readonlytpostgresql_deferrableRhR�
RkR�
R�
RmR�
tignore_search_pathR�
R�
R�
R�
R�
tpostgresql_ignore_search_pathcKs2tj
j||�

|
|_||_||_dS(
N(RtDefaultDialectR�tisolation_levelt_json_deserializert_json_serializer(R�Rvtjson_serializertjson_deserializerR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�`
s	
	
cCs
tt
|�j|
�

|jdk
r8t|_|_n|jd	k|_|js�|jj	�|_|jj
tjd�
|jj
td�
n|jd
k|_|jdkr�t|_n$|
jd�
j�}|dk|_|jdk|_|jd
k|_|jdk|_dS(Niiii	s show standard_conforming_stringsRQi
(ii(ii(i	i(ii(ii(i	i(
i
(R�Rot
initializetserver_version_infoR�tfull_returningtimplicit_returningR�tcolspecstcopyR�RR�
R�R�R�
RD
texec_driver_sqltscalarR�
R�
R�
(R�R�t
std_string((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR{p
s&


	




c
s*�jdk	r"�f
d
�}
|
SdSdS(Nc

s�j|�j
�
dS(
N(tset_isolation_levelRv(
RI(
R�(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytconnect�
s
(RvR�(R�R�((
R�sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
on_connect�
s
tSERIALIZABLEsREAD UNCOMMITTEDsREAD COMMITTEDsREPEATABLE READcCs�|jd
d�}||j
krOtjd||jdj|j
�
f�
�
n|
j�}|jd|�

|jd�

|j�
dS(NR�
R�
sLInvalid value '%s' for isolation_level. Valid isolation levels for %s are %ss, s=SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL %stCOMMIT(	RE
t_isolation_lookupRt
ArgumentErrorR�RytcursorR�tclose(R�R�tlevelR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��
s



%




cCs=|
j�}|j
d
�

|j�d}|j�
|j�S(Ns show transaction isolation leveli(R�R�tfetchoneR�RN
(R�R�R�tval((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_isolation_level�
s







c
Cs
t��
dS(
N(
tNotImplementedError(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRe�
s
c
Cs
t��
dS(
N(
R�(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRi�
s
c
Cs
t��
dS(
N(
R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRm�
s
c
Cs
t��
dS(
N(
R�(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRn�
s
cCs|j|
j
�

dS(
N(tdo_beginR�(R�R�txid((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_begin_twophase�
s
cCs|
jd
|�

dS(NsPREPARE TRANSACTION '%s'(
R�(R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_prepare_twophase�
s
cCsa|rM|r|
jd
�

n|
jd|�

|
jd�

|j
|
j�

n|j
|
j�

dS(NtROLLBACKsROLLBACK PREPARED '%s'tBEGIN(R�tdo_rollbackR�(R�R�R�tis_preparedtrecover((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_rollback_twophase�
s




cCsa|rM|r|
jd
�

n|
jd|�

|
jd�

|j
|
j�

n|j|
j�

dS(NR�sCOMMIT PREPARED '%s'R�(R�R�R�t	do_commit(R�R�R�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_commit_twophase�
s





cCs3|
jt
jd
�
�
}g|D]}|d^qS(Ns!SELECT gid FROM pg_prepared_xactsi(R�R	R
(R�R�t	resultsettrow((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_recover_twophase�
s

cCs|
jd
�
j
�S(Nsselect current_schema()(R�R�(R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_get_default_schema_name�
s
cCs[d
}|
jt
j|�
jt
jdtj|j��
dtj	�
�
�
}t
|j��
S(Ns=select nspname from pg_namespace where lower(nspname)=:schemaRR�(R�R	R
t
bindparamst	bindparamR
R�R�
RtUnicodetbooltfirst(R�R�RtqueryR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
has_schema�
s




cCs�|j|
�

|dkr[|
jtjd
�
jtjdtj|�
dt	j
�
�
�
}n`|
jtjd�
jtjdtj|�
dt	j
�
tjdtj|�
dt	j
�
��
}t|j��
S(Ns�select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where pg_catalog.pg_table_is_visible(c.oid) and relname=:nameR�R�stselect relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where n.nspname=:schema and relname=:nameR(
t_ensure_has_table_connectionR�R�R	R
R�R�R
R�RR�R�R�(R�R�RHRR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt	has_tables*




	




	


	


cCs�|dkr|j
}n|
jtjd
�
jtjdtj|�
dt	j
�
tjdtj|�
dt	j
�
��
}t|j��
S(Ns�SELECT relname FROM pg_class c join pg_namespace n on n.oid=c.relnamespace where relkind='S' and n.nspname=:schema and relname=:nameR�R�R(
R�RJR�R	R
R�R�R
R�RR�R�R�(R�R�t
sequence_nameRR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pythas_sequence,s




	


	


cCs�|dk	r$d
}t
j|�
}nd}t
j|�
}|jt
jdtj|�
dtj�
�
}|dk	r�|jt
jdtj|�
dtj�
�
}n|
j	|�
}t
|j��
S(Ns

            SELECT EXISTS (
                SELECT * FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n
                WHERE t.typnamespace = n.oid
                AND t.typname = :typname
                AND n.nspname = :nspname
                )
                s�
            SELECT EXISTS (
                SELECT * FROM pg_catalog.pg_type t
                WHERE t.typname = :typname
                AND pg_type_is_visible(t.oid)
                )
                ttypnameR�tnspname(R�R	R
R�R�R
R�RR�R�R�R�(R�R�t	type_nameRR�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Ds





!


$
cCs~|
jd
�
j
�}tjd|�}|s@td|�
�
ntg|jddd�D]}|dk	rYt|�
^qY�
S(Nsselect pg_catalog.version()sQ.*(?:PostgreSQL|EnterpriseDB) (\d+)\.?(\d+)?(?:\.(\d+))?(?:\.\d+)?(?:devel|beta)?s,Could not determine version from string '%s'i
ii(	R�R�R6RbtAssertionErrorRRCR�tint(R�R�R�
t
mt
x((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_get_server_version_infofs


	

c
Ks
d}|dk	rd
}nd}d|}t
j|�
}|dk	rXt
j|�
}ntj|�
jdtj�
}|jdtj	�
}|r�|jtj
ddtj�

�
}n|
j|td|d|��}	|	j
�}|dkr
tj|�
�
n|S(	s�Fetch the oid for schema.table_name.

        Several reflection methods require the table oid.  The idea for using
        this method is that it can be fetched one time and cached for
        subsequent calls.

        sn.nspname = :schemas%pg_catalog.pg_table_is_visible(c.oid)s	

            SELECT c.oid
            FROM pg_catalog.pg_class c
            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
            WHERE (%s)
            AND c.relname = :table_name AND c.relkind in
            ('r', 'v', 'm', 'f', 'p')
        RHR
RR�N(R�R
R�R	R
R�RR�Rm
tIntegerR�R�R�
R�RtNoSuchTableError(
R�R�RHRR�t	table_oidtschema_where_clauseR�Rr
Re
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRGss$	

		






$
!



cKsA|
jt
jd
�
jdtj�
�
}g|D]\
}|^q.S(NsOSELECT nspname FROM pg_namespace WHERE nspname NOT LIKE 'pg_%' ORDER BY nspnameR�(R�R	R
Rm
RR�(R�R�R�tresultR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_schema_names�s


cKsb|
jt
jd
�
jdtj�
td|dk	r9|n|j�
�}g|D]\
}|^qOS(Ns�SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = :schema AND c.relkind in ('r', 'p')trelnameR(	R�R	R
Rm
RR�R�
R�RJ(R�R�RR�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_table_names�s

	

cKsb|
jt
jd
�
jdtj�
td|dk	r9|n|j�
�}g|D]\
}|^qOS(Ns|SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = :schema AND c.relkind = 'f'R�R(	R�R	R
Rm
RR�R�
R�RJ(R�R�RR�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRM�s

	

RORPc
Ks�id
d6dd6}y*gtj
|�
D]}||^q'}Wn$tk
rd


td|f
�
�
n
X|sztd�
�
n|
jtjddjd	�|D�
�
�
jd
t	j
�
td|dk	r�|n|j
�
�}g|D]\
}	|	^q�S(NR�
ROR�RPs_include %r unknown, needs to be a sequence containing one or both of 'plain' and 'materialized'sZempty include, needs to be a sequence containing one or both of 'plain' and 'materialized's~SELECT c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = :schema AND c.relkind IN (%s)s, c
ss|]}
d|
V
qd
S(s'%s'N((RA
telem((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�sR�R(R
tto_listtKeyErrort
ValueErrorR�R	R
RyRm
RR�R�
R�RJ(
R�R�RR�
R�tinclude_kindR6
tkindsR�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRQ�s&

*








 
	

cKsl|s|j}n|
j
tjd
�
jtjdtj|�
dtj	�
�
�
}g|D]}|d^qXS(NsrSELECT relname FROM pg_class c join pg_namespace n on n.oid=c.relnamespace where relkind='S' and n.nspname=:schemaRR�i(
RJR�R	R
R�R�R
R�RR�(R�R�RR�R�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_sequence_names�s



	


cKsR|
jt
jd
�
jdtj�
td|dk	r9|n|jd|��}|S(Ns�SELECT pg_get_viewdef(c.oid) view_def FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = :schema AND c.relname = :view_name AND c.relkind IN ('v', 'm')tview_defRt	view_name(	R�R	R
Rm
RR�R�
R�RJ(R�R�R�RR�R�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_view_definition�s

	

	
cKst
|j|
||d
|j
d
�
�
}|jdkr9dnd}|jdkrWd}nd}d||f}tj|�
jtjd	d
tj�

�
j	dtj
dtj
�}	|
j|	td	|�
�}
|
j
�}|j|
�
}td
�|j|
dd�

D�
�
}
g}x]|D]U\}}}}}}}}|j||||||
||||�
}|j|�

q
W|S(NREisa.attgenerated as generatedsNULL as generatedi
s�                (SELECT json_build_object(
                    'always', a.attidentity = 'a',
                    'start', s.seqstart,
                    'increment', s.seqincrement,
                    'minvalue', s.seqmin,
                    'maxvalue', s.seqmax,
                    'cache', s.seqcache,
                    'cycle', s.seqcycle)
                FROM pg_catalog.pg_sequence s
                JOIN pg_catalog.pg_class c on s.seqrelid = c."oid"
                WHERE c.relkind = 'S'
                AND a.attidentity != ''
                AND s.seqrelid = pg_catalog.pg_get_serial_sequence(
                    a.attrelid::regclass::text, a.attname
                )::regclass::oid
                ) as identity_options                sNULL as identity_optionss
            SELECT a.attname,
              pg_catalog.format_type(a.atttypid, a.atttypmod),
              (
                SELECT pg_catalog.pg_get_expr(d.adbin, d.adrelid)
                FROM pg_catalog.pg_attrdef d
                WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum
                AND a.atthasdef
              ) AS DEFAULT,
              a.attnotnull,
              a.attrelid as table_oid,
              pgd.description as comment,
              %s,
              %s
            FROM pg_catalog.pg_attribute a
            LEFT JOIN pg_catalog.pg_description pgd ON (
                pgd.objoid = a.attrelid AND pgd.objsubid = a.attnum)
            WHERE a.attrelid = :table_oid
            AND a.attnum > 0 AND NOT a.attisdropped
            ORDER BY a.attnum
        R�R�tattnameRc
ssF|]<}
|
dr&|
d
f
|
fn|
d|
d
f|
fV
qdS(tvisibleR�RN((RA
trec((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>XsRt
*(
i(
i
(RGR�R|R	R
R�R�RR�Rm
R�R�R�
tfetchallt
_load_domainsRKt_get_column_infoR�
(R�R�RHRR�R�RR�
tSQL_COLSRr
Re
trowstdomainsR�Rm
R�R�
tdefault_R}tcommenttcolumn_info((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_columns
sF

	






	"










	
c
Csqd
�}|dkr.t
}d}
}t}n-t}tjdd|�}
||
�
\}
}ttj|
�
�
}|}tjd|�}|r�|j	d�
}ntjd|�}|r�|j	d�
r�ttj
d|j	d�
��
}nd2}i}|
d	krC
|r:
|j
d
�
\}}t|�
t|�
f}q�d3}nT
|
dkrX
d4}n?
|
d
krm
d5}n*
|
d6kr�
t
|d<|r�
t|�
|d<nd7}n�|
d8kr�
t|d<|r�
t|�
|d<nd9}n�|
dkrt
|d<|rt|�
f
}q�d:}n�|
jd�
rtj
d|
tj�}|rTt|�
|d<n|rp|j	d�
|d<nd}
d;}n|r�t|�
f
}nx
t
r�|
|jkr�|j|
}Pq�||kr||}t}|d|d<|ds|d|d<nt|d�
}Pq�||kr�||}|d}
||
�
\}
}ttj|
�
�
}|om|d}|d r�|r�|d }q�q�q�d}Pq�W|r�|||�}|r|jd!|�
}qnF|r�tjd"|
f
�

tj}n tjd#|
|
f�

tj}|	d<krItd%|d&|	d=k�}d}nd}t}|dk	rtjd(|�}|dk	rt|jtj�r�t
}n|}d)|j	d*�
kr�|dk	r�|j	d�
d+|d)|j	d*�
|j	d,�
}q�qntd|
d-|d|d |d.|p/|
dk	d/|�}|dk	rT||d0<n|
dk	rm|
|d1<n|S(>Nc

Ss"tj
d
d|�|jd�
fS(Ns\[\]$R2
s[](R6R7tendswith(
tattype((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_handle_array_type�s
sno format_type()s\(.*\)R2
s\(([\d,]+)\)i
s\((.*)\)s\s*,\s*R
t
,sdouble precisioni5R

stimestamp with time zonestime with time zoneR�R�stimestamp without time zonestime without time zoneR
sbit varyingR�R�s
interval (.+)R�R�R�RtlabelsR�R�
RR�s6PostgreSQL format_type() returned NULL for column '%s's*Did not recognize type '%s' of column '%s's
RP
RRr
s(nextval\(')([^']+)('.*$)R?is"%s"iR�t
autoincrementR�R�
R�
(((
i5((stimestamp with time zonestime with time zone((stimestamp without time zonestime without time zoneR
((((NR2
s
(Rr
Rr
(R�R�R�R6R7RR
tquoted_token_parsertsearchRCtsplitR�t
startswithRbt
It
ischema_namesR�R�RtNULLTYPER�
t
issubclassR�R�(R�R�R�
RR}R�R�RR�RR�
R�tno_format_typeR�tis_arraytenum_or_domain_keyR�
tcharlentargsR�tprectscaletfield_matchR�R�tdomainR�
R�RbtschR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�zs�
	



	




$



	

	

	





	



	



	




	







	

	






























	

	




	
!	>





	





c
Ks
|j|
||d
|j
d
�
�
}|jdkrLd|jdd�}nd}tj|�
jdtj�
}|
j	|t
d	|�
�}g|j�D]}	|	d
^q�}
d}tj|�
jdtj�
}|
j	|t
d	|�
�}|j�}i|
d
6|d6S(NREiisq

                SELECT a.attname
                FROM
                    pg_class t
                    join pg_index ix on t.oid = ix.indrelid
                    join pg_attribute a
                        on t.oid=a.attrelid AND %s
                 WHERE
                  t.oid = :table_oid and ix.indisprimary = 't'
                ORDER BY a.attnum
            sa.attnums	ix.indkeys�

                SELECT a.attname
                FROM pg_attribute a JOIN (
                    SELECT unnest(ix.indkey) attnum,
                           generate_subscripts(ix.indkey, 1) ord
                    FROM pg_index ix
                    WHERE ix.indrelid = :table_oid AND ix.indisprimary
                    ) k ON a.attnum=k.attnum
                WHERE a.attrelid = :table_oid
                ORDER BY k.ord
            R�R�is�
        SELECT conname
           FROM  pg_catalog.pg_constraint r
           WHERE r.conrelid = :table_oid AND r.contype = 'p'
           ORDER BY 1
        tconnametconstrained_columnsR�(ii(
RGR�R|t
_pg_index_anyR	R
Rm
RR�R�R�
R�R�(
R�R�RHRR�R�tPK_SQLR�
Re
t
rR�
tPK_CONS_SQLR�((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_pk_constraint1s
	



#


cKs_|j}|j
|
||d
|jd
�
�
}d}tjd�
}	tj|�
jdtj	dtj	�}
|
j
|
td|�
�}g}x�
|j�D]�
\}
}}tj
|	|�j�}|\
}}}}}}}}}}}}}|dk	r
|dkr	
tnt}ngtjd|�D]}|j|�
^q%
}|rg
||jkr^
|}q�
|}n9|r
|j|�
}n!|dk	r�
||kr�
|}n|j|�
}gtjd	|�D]}|j|�
^q�
}d
�d|fd|fd
|fd|fd|fgD�
}i|
d6|d6|d6|d6|d6|d6}|j|�

q�W|S(NREs�

          SELECT r.conname,
                pg_catalog.pg_get_constraintdef(r.oid, true) as condef,
                n.nspname as conschema
          FROM  pg_catalog.pg_constraint r,
                pg_namespace n,
                pg_class c

          WHERE r.conrelid = :table AND
                r.contype = 'f' AND
                c.oid = confrelid AND
                n.oid = c.relnamespace
          ORDER BY 1
        s/
FOREIGN KEY \((.*?)\) REFERENCES (?:(.*?)\.)?(.*?)\((.*?)\)[\s]?(MATCH (FULL|PARTIAL|SIMPLE)+)?[\s]?(ON UPDATE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT)+)?[\s]?(ON DELETE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT)+)?[\s]?(DEFERRABLE|NOT DEFERRABLE)?[\s]?(INITIALLY (DEFERRED|IMMEDIATE)+)?R�tcondefR`t
DEFERRABLEs\s*,\s*s\s*,\sc
Ss7i|]-\}
}|d
k	r|dkr||
�qS(s	NO ACTIONN(
R�(RA
R�
R�
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys
<dictcomp>�s	
	tonupdatetondeleteRFR6RbR�R�treferred_schematreferred_tabletreferred_columnstoptions(R�
RGR�R6tcompileR	R
Rm
RR�R�R�
R�R�tgroupsR�R�R�R�R>RJR�
(R�R�RHRRtR�RF
R�tFK_SQLtFK_REGEXR�
Re
tfkeysR�R�t	conschemaR�R�R�R�R�R�
RbR�R�R6RFR�R�tfkey_d((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_foreign_keysdsV		


	




-

+
		

	
+	
	
	
	








csN|jd	kr<ddj
��
fd�tdd�D�
�
Sd��
fSdS(
Nii
s(%s)s OR c
3s"|]}
d�
|
�fV
qd
S(s%s[%d] = %sN((RA
tind(RV
t
compare_to(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�sii
s%s = ANY(%s)(ii
(R|Rytrange(R�RV
R((RV
RsT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR��s
	
$c&
s-|j|
||d
|j
d
�
�
}|jd/kr�d|jd0krKdnd|jd1krcdnd	|jd2kr{dnd	|jdd
�f}n"d|jd3kr�dnd	f
}tj|�
jdtjdtj�}|
j	|t
d|�
�}td��
}	d}
xs|j
�D]e}|\}}
}}}}}}}}}}|r
||
krs
tjd|�

n|}
q
n||	k}|	|}|dk	r�
||d|<n|s
|j�}|r�
||r�
||}|| }ng}g|D]}t|j��
^q�
|d<g|D]}t|j��
^q!|d<i}x�t|pXdj��
D]|\}}t|j��
}d4} |d@r�| d57} |d
@s�| d67} q�n|d
@r�| d77} n| rb| ||<qbqbW|r�||d<n|
|d<|dk	r||d <n|rMt
g|D]}!|!jd!�
^q(�
|d"<n|rl|d#krl||d$<n|r�||d%<q�q
q
Wg}"x�
|	j�D]�
\}#�i|#d&6�dd6g�dD]}$�d|$^q�d'6}%|jd8krg�dD]}$�d|$^q�|%d(<nd �kr;�d |%d <nd�krtt
�f
d)��dj�D�
�
|%d*<nd(|%kr�|%d(|%jd+i�d,<nd"�kr��d"|%jd+i�d-<nd$�kr��d$|%jd+i�d.<nd%�kr�d%|%jd+i�d%<n|"j|%�

q�W|"S(9NREiis�
              SELECT
                  i.relname as relname,
                  ix.indisunique, ix.indexprs, ix.indpred,
                  a.attname, a.attnum, NULL, ix.indkey%s,
                  %s, %s, am.amname,
                  NULL as indnkeyatts
              FROM
                  pg_class t
                        join pg_index ix on t.oid = ix.indrelid
                        join pg_class i on i.oid = ix.indexrelid
                        left outer join
                            pg_attribute a
                            on t.oid = a.attrelid and %s
                        left outer join
                            pg_am am
                            on i.relam = am.oid
              WHERE
                  t.relkind IN ('r', 'v', 'f', 'm')
                  and t.oid = :table_oid
                  and ix.indisprimary = 'f'
              ORDER BY
                  t.relname,
                  i.relname
            is	::varcharR2
six.indoption::varchartNULLisi.reloptionssa.attnums	ix.indkeys/
              SELECT
                  i.relname as relname,
                  ix.indisunique, ix.indexprs,
                  a.attname, a.attnum, c.conrelid, ix.indkey::varchar,
                  ix.indoption::varchar, i.reloptions, am.amname,
                  pg_get_expr(ix.indpred, ix.indrelid),
                  %s as indnkeyatts
              FROM
                  pg_class t
                        join pg_index ix on t.oid = ix.indrelid
                        join pg_class i on i.oid = ix.indexrelid
                        left outer join
                            pg_attribute a
                            on t.oid = a.attrelid and a.attnum = ANY(ix.indkey)
                        left outer join
                            pg_constraint c
                            on (ix.indrelid = c.conrelid and
                                ix.indexrelid = c.conindid and
                                c.contype in ('p', 'u', 'x'))
                        left outer join
                            pg_am am
                            on i.relam = am.oid
              WHERE
                  t.relkind IN ('r', 'v', 'f', 'm', 'p')
                  and t.oid = :table_oid
                  and ix.indisprimary = 'f'
              ORDER BY
                  t.relname,
                  i.relname
            iisix.indnkeyattsR�R�R�cSs
tt
�
S(
N(RR�
(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt<lambda>>R2
s;Skipped unsupported reflection of expression-based index %sR�
R�
tinci
R7t
nulls_lasttnulls_firsttsortingRftduplicates_constraintt
=R�tbtreetamnametpostgresql_whereR�tcolumn_namestinclude_columnsc
3s1|]'\}
}�d�d
|
|fV
qdS(R�
R�
N((RA
R6
R�(
tidx(sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys	<genexpr>�s
tcolumn_sortingR�
tpostgresql_includetpostgresql_withtpostgresql_using(ii(ii(ii(ii(ii((
R7(
R
(
R(ii(RGR�R|R�R	R
Rm
RR�R�R�
RR�R�R
R�R�R�tstript	enumerateR�
R�R�
(&R�R�RHRR�R�tIDX_SQLR�
Re
tindexestsv_idx_nameR�tidx_nameRfR�
RV
tcol_numtconrelidtidx_keyt
idx_optionR�Rtfilter_definitiontindnkeyattsthas_idxR�
tidx_keystinc_keysR�
Rtcol_idxt	col_flagstcol_sortingtoptionR�R�R6
tentry((
RsT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_indexes�s�



!



*













)
)























,







),










cKs
|j|
||d
|j
d
�
�
}d}tj|�
jdtj�
}|
j|td|�
�}t	d��
}	xB|j
�D]4}
|	|
j}|
j|d<|
j
|d|
j<qWg|	j�D]?\}}i|d6g|dD]}
|d|
^q�d	6^q�S(
NREs�

            SELECT
                cons.conname as name,
                cons.conkey as key,
                a.attnum as col_num,
                a.attname as col_name
            FROM
                pg_catalog.pg_constraint cons
                join pg_attribute a
                  on cons.conrelid = a.attrelid AND
                    a.attnum = ANY(cons.conkey)
            WHERE
                cons.conrelid = :table_oid AND
                cons.contype = 'u'
        tcol_nameR�cSs
tt
�
S(
N(RR�
(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�R2
R�
R�
R�R(RGR�R	R
Rm
RR�R�R�
RR�R�R�
R.RR�
(R�R�RHRR�R�t
UNIQUE_SQLR�
Re
tuniquesR�tucR�R6
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_unique_constraints�s








cKs_|j|
||d
|j
d
�
�
}d}|
jtj|�
td|�
�}i
|j�d6S(NREs�
            SELECT
                pgd.description as table_comment
            FROM
                pg_catalog.pg_description pgd
            WHERE
                pgd.objsubid = 0 AND
                pgd.objoid = :table_oid
        R�R
(RGR�R�R	R
R�
R�(R�R�RHRR�R�tCOMMENT_SQLRe
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_table_comment�s

cKs!
|j|
||d
|j
d
�
�
}d}|
jtj|�
td|�
�}g}x�|D]�\}	}
tjd|
dtj�
}|s�t	j
d|
�

d}n-tjddtj�

jd	|j
d
�
�}i|	d6|d6}
|r
|j
d
�
r
i
td6|
d<n|j|
�

q[W|S(NREs

            SELECT
                cons.conname as name,
                pg_get_constraintdef(cons.oid) as src
            FROM
                pg_catalog.pg_constraint cons
            WHERE
                cons.conrelid = :table_oid AND
                cons.contype = 'c'
        R�s^CHECK *\((.+)\)( NOT VALID)?$R5
s)Could not parse CHECK constraint text: %rR2
s^[\s\n]*\((.+)\)[\s\n]*$s\1i
R�RP
iR�
R�
(RGR�R�R	R
R�
R6RbtDOTALLR
R�R�R7RCR�R�
(R�R�RHRR�R�t	CHECK_SQLRe
tretR�tsrcR�RP
R,((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_check_constraints�s&
$



	





cCsb
|p|j}|j
siSd
}|dkr;|d7}n|d7}tj|�
jdtjdtj�}|dkr�|jd|�
}n|
j|�
}g}i}x�|j	�D]�}|j
|jf}	|	|kr�||	dj|j
�

q�i|jd	6|j
d6|jd
6gd6||	<}
|j
dk	rM
|
dj|j
�

n|j|
�

q�W|S(Ns�

            SELECT t.typname as "name",
               -- no enum defaults in 8.4 at least
               -- t.typdefault as "default",
               pg_catalog.pg_type_is_visible(t.oid) as "visible",
               n.nspname as "schema",
               e.enumlabel as "label"
            FROM pg_catalog.pg_type t
                 LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
                 LEFT JOIN pg_catalog.pg_enum e ON t.oid = e.enumtypid
            WHERE t.typtype = 'e'
        R�sAND n.nspname = :schema s ORDER BY "schema", "name", e.oidR�tlabelRR�R�R�(RJR�R	R
Rm
RR�R�R�R�RR�R�
R:R�R�(R�R�Rt	SQL_ENUMSRr
Re
R�tenum_by_nameR�R�
tenum_rec((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRK#s6

	




















c	Cs�d
}tj
|�
}|
jdt�
j|�
}i}x�|j�D]�}|}tjd|d�jd�
}|dr�|df
}n|d|df}i|d6|d	d	6|d
d
6||<qCW|S(Ns�

            SELECT t.typname as "name",
               pg_catalog.format_type(t.typbasetype, t.typtypmod) as "attype",
               not t.typnotnull as "nullable",
               t.typdefault as "default",
               pg_catalog.pg_type_is_visible(t.oid) as "visible",
               n.nspname as "schema"
            FROM pg_catalog.pg_type t
               LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
            WHERE t.typtype = 'd'
        t
future_results([^\(]+)R�i
R�R�RR�
R(	R	R
texecution_optionsR�R�tmappingsR6R�RC(	R�R�tSQL_DOMAINSRr
Re
R�R�R�R�
((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR�Ws







N(
Rt(RORP(cR�R�R�R�tsupports_statement_cachetsupports_altertmax_identifier_lengthtsupports_sane_rowcountR�tsupports_native_booleanR�
tsupports_sequencestsequences_optionalt"preexecute_autoincrement_sequencesR�tpostfetch_lastrowidtsupports_commentstsupports_default_valuestsupports_default_metavaluetsupports_empty_inserttsupports_multivalues_insertR�
tdefault_paramstyleR�RR
tstatement_compilerR�
tddl_compilerRR?
R:RF
RTtexecution_ctx_clsRDt	inspectorR�RvR~R}RRutconnection_characteristicsReRdRlRtIndextTabletCheckConstrainttForeignKeyConstrainttconstruct_argumentstreflection_optionsRD
R�
R�
R�R{R�R�R�R�R�ReRiRmRnR�R�R�R�R�R�R�R�R�R�R�R
tcacheRGR�R�RMRQR�R�R�R�R�RR�R-R2R4R9RKR�(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRo
s�



















































	$	



											'"	

'

 


l	�
2
m	�$

,4({R�tcollectionsRtdatetimeR�R6R
R
R�R2
RR�RRt_hstoreRt_jsonRt_rangesRRR	R
tengineRRR
RRRRRRR_
tsql.ddlRttypesRRRRRRRRRRRR�R�R�
tUNICODERaR�RBt_DECIMAL_TYPESt_FLOAT_TYPESt
_INT_TYPEStLargeBinaryR�tFloatR�t
TypeEngineR�tPGInetR�tPGCidrR�t	PGMacAddrR�t
PGMacAddr8R�R�R�R�R�tNativeForEmulatedt_AbstractIntervalR�t
PGIntervalR�tPGBittPGUuidR�R�
R�tCastR�R�
R�tJSONPathTypeR#
RRRRRR R"R$R&tStringR�tSQLCompilerR
tDDLCompilerR�
tGenericTypeCompilerRtIdentifierPreparerR:t	InspectorRDt_CreateDropBaseR�R�tDefaultExecutionContextRTtConnectionCharacteristicRdRlRuRo(((sT/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt<module>�s�









































































































































-(
R�
	































































���,�B;