Current File : //opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyc
�
��4]c g @ s� d Z d d l m Z d d l Z d d l Z d d l m Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d
l m
Z
d d l m Z d d l m Z d d
l m Z d d l m Z d d l m
Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z y d d l m Z! Wn e" k
r�e# Z! n Xe j$ d e j% � Z& e j$ d e j% e j' B� Z( e) d d d d d! d" d# d$ d% d& d' d( d) d* d+ d, d- d. d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH dI dJ dK dL dM dN dO dP dQ dR dS dT dU dV dW dX dY dZ d[ d\ d] d^ d_ d` da db dc dd de df dg dh di dj dk dl dm dn do dp dq dr ds dt du dv dw dx dy dz d{ d| d} d~ d d� d� d� gf � Z* d� d� f Z+ d� d� d� d� f Z, d� d� d� d� d� d� d� f Z- d� e j. f d� � � YZ/ d� e j0 f d� � � YZ1 d� e j2 f d� � � YZ3 e3 Z4 d� e j2 f d� � � YZ5 e5 Z6 d� e j2 f d� � � YZ7 e7 Z8 d� e j2 f d� � � YZ9 d� e j2 f d� � � YZ: d� e j2 f d� � � YZ; d� e j< f d� � � YZ< d� e j= f d� � � YZ= d� e j> e j? f d� � � YZ@ e@ ZA d� e j2 f d� � � YZB eB ZC d� e j2 f d� � � YZ e ZD d� e j2 f d� � � YZE d� e j> e jF f d� � � YZG i e@ e jH 6eG e jF 6ZI i e d� 6e d� 6e d� 6e d� 6e d� 6e jJ d� 6e jJ d� 6e d� 6e d� 6e d� 6e d� 6e3 d� 6e5 d� 6e d� 6eB d� 6eB d� 6e7 d� 6e9 d� 6e: d� 6e; d� 6e1 d� 6e< d� 6e< d� 6e< d� 6e= d� 6e= d� 6e d� 6e= d� 6e/ d� 6e d� 6e@ d� 6eE d� 6ZK d� e jL f d� � � YZM d� e jN f d� � � YZO d� e jP f d� � � YZQ d� e jR f d� � � YZS d� e
jT f d� � � YZU d� e jV f d� � � YZW d� e jV f d� � � YZX d� e jY f d� � � YZZ d� e j[ f d� � � YZ\ d S(� s�
.. dialect:: postgresql
:name: PostgreSQL
.. _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:`.create_engine`.
PostgreSQL 10 IDENTITY columns
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
PostgreSQL 10 has a new IDENTITY feature that supersedes the use of SERIAL.
Built-in support for rendering of IDENTITY is not available yet, however the
following compilation hook may be used 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 NOT NULL,
data VARCHAR,
PRIMARY KEY (id)
)
.. _postgresql_isolation_level:
Transaction Isolation Level
---------------------------
All PostgreSQL dialects support setting of transaction isolation level
both via a dialect-specific parameter
:paramref:`.create_engine.isolation_level` accepted by :func:`.create_engine`,
as well as the :paramref:`.Connection.execution_options.isolation_level`
argument as passed to :meth:`.Connection.execution_options`.
When using a non-psycopg2 dialect, this feature works by issuing the command
``SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL <level>`` for
each new connection. For the special AUTOCOMMIT isolation level,
DBAPI-specific techniques are used.
To set isolation level using :func:`.create_engine`::
engine = create_engine(
"postgresql+pg8000://scott:tiger@localhost/test",
isolation_level="READ UNCOMMITTED"
)
To set using per-connection execution options::
connection = engine.connect()
connection = connection.execution_options(
isolation_level="READ COMMITTED"
)
Valid values for ``isolation_level`` include:
* ``READ COMMITTED``
* ``READ UNCOMMITTED``
* ``REPEATABLE READ``
* ``SERIALIZABLE``
* ``AUTOCOMMIT`` - on psycopg2 / pg8000 only
.. seealso::
:ref:`psycopg2_isolation_level`
:ref:`pg8000_isolation_level`
.. _postgresql_schema_reflection:
Remote-Schema Table Introspection and PostgreSQL search_path
------------------------------------------------------------
**TL;DR;**: keep the ``search_path`` variable set to its default of ``public``,
name schemas **other** than ``public`` explicitly within ``Table`` definitions.
The PostgreSQL dialect can reflect tables from any schema. The
:paramref:`.Table.schema` argument, or alternatively the
:paramref:`.MetaData.reflect.schema` argument determines which schema will
be searched for the table or tables. The reflected :class:`.Table` objects
will in all cases retain this ``.schema`` attribute as was specified.
However, with regards to tables which these :class:`.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
<http://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
>>> engine = create_engine("postgresql://scott:tiger@localhost/test")
>>> with engine.connect() as conn:
... conn.execute("SET search_path TO test_schema, public")
... meta = MetaData()
... referring = Table('referring', meta,
... autoload=True, autoload_with=conn)
...
<sqlalchemy.engine.result.ResultProxy object at 0x101612ed0>
The above process would deliver to the :attr:`.MetaData.tables` collection
``referred`` table named **without** the schema::
>>> meta.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:`.Table` as well as
:meth:`.MetaData.reflect`::
>>> with engine.connect() as conn:
... conn.execute("SET search_path TO test_schema, public")
... meta = MetaData()
... referring = Table('referring', meta, autoload=True,
... autoload_with=conn,
... postgresql_ignore_search_path=True)
...
<sqlalchemy.engine.result.ResultProxy object at 0x1016126d0>
We will now have ``test_schema.referred`` stored as schema-qualified::
>>> meta.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:`.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``.
.. versionadded:: 0.9.2 Added the ``postgresql_ignore_search_path``
dialect-level option accepted by :class:`.Table` and
:meth:`.MetaData.reflect`.
.. seealso::
`The Schema Search Path
<http://www.postgresql.org/docs/9.0/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.dml.insert()` function, which provides
the generative methods :meth:`~.postgresql.dml.Insert.on_conflict_do_update`
and :meth:`~.postgresql.dml.Insert.on_conflict_do_nothing`::
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']
)
conn.execute(do_nothing_stmt)
do_update_stmt = insert_stmt.on_conflict_do_update(
constraint='pk_my_table',
set_=dict(data='updated value')
)
conn.execute(do_update_stmt)
Both methods supply the "target" of the conflict using either the
named constraint or by column inference:
* The :paramref:`.Insert.on_conflict_do_update.index_elements` argument
specifies a sequence containing string column names, :class:`.Column`
objects, and/or SQL expression elements, which would identify a unique
index::
do_update_stmt = insert_stmt.on_conflict_do_update(
index_elements=['id'],
set_=dict(data='updated value')
)
do_update_stmt = insert_stmt.on_conflict_do_update(
index_elements=[my_table.c.id],
set_=dict(data='updated value')
)
* When using :paramref:`.Insert.on_conflict_do_update.index_elements` to
infer an index, a partial index can be inferred by also specifying the
use the :paramref:`.Insert.on_conflict_do_update.index_where` parameter::
from sqlalchemy.dialects.postgresql import insert
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)
)
conn.execute(stmt)
* The :paramref:`.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::
do_update_stmt = insert_stmt.on_conflict_do_update(
constraint='my_table_idx_1',
set_=dict(data='updated value')
)
do_update_stmt = insert_stmt.on_conflict_do_update(
constraint='my_table_pk',
set_=dict(data='updated value')
)
* The :paramref:`.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:`.Table` using the
:attr:`.Table.primary_key` attribute::
do_update_stmt = insert_stmt.on_conflict_do_update(
constraint=my_table.primary_key,
set_=dict(data='updated value')
)
``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:`.Insert.on_conflict_do_update.set_` parameter. This
parameter accepts a dictionary which consists of direct values
for UPDATE::
from sqlalchemy.dialects.postgresql import insert
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')
)
conn.execute(do_update_stmt)
.. warning::
The :meth:`.Insert.on_conflict_do_update` method does **not** take into
account Python-side default UPDATE values or generation functions, e.g.
e.g. those specified using :paramref:`.Column.onupdate`.
These values will not be exercised for an ON CONFLICT style of UPDATE,
unless they are manually specified in the
:paramref:`.Insert.on_conflict_do_update.set_` dictionary.
In order to refer to the proposed insertion row, the special alias
:attr:`~.postgresql.dml.Insert.excluded` is available as an attribute on
the :class:`.postgresql.dml.Insert` object; this object is a
:class:`.ColumnCollection` which alias contains all columns of the target
table::
from sqlalchemy.dialects.postgresql import insert
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)
)
conn.execute(do_update_stmt)
The :meth:`.Insert.on_conflict_do_update` method also accepts
a WHERE clause using the :paramref:`.Insert.on_conflict_do_update.where`
parameter, which will limit those rows which receive an UPDATE::
from sqlalchemy.dialects.postgresql import insert
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)
)
conn.execute(on_update_stmt)
``ON CONFLICT`` may also 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.dml.Insert.on_conflict_do_nothing` method::
from sqlalchemy.dialects.postgresql import insert
stmt = insert(my_table).values(id='some_id', data='inserted value')
stmt = stmt.on_conflict_do_nothing(index_elements=['id'])
conn.execute(stmt)
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::
from sqlalchemy.dialects.postgresql import insert
stmt = insert(my_table).values(id='some_id', data='inserted value')
stmt = stmt.on_conflict_do_nothing()
conn.execute(stmt)
.. versionadded:: 1.1 Added support for PostgreSQL ON CONFLICT clauses
.. seealso::
`INSERT .. ON CONFLICT
<http://www.postgresql.org/docs/current/static/sql-insert.html#SQL-ON-CONFLICT>`_
- in the PostgreSQL documentation.
.. _postgresql_match:
Full Text Search
----------------
SQLAlchemy makes available the PostgreSQL ``@@`` operator via the
:meth:`.ColumnElement.match` method on any textual column expression.
On a 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
The PostgreSQL text search functions such as ``to_tsquery()``
and ``to_tsvector()`` are available
explicitly using the standard :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
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.
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.
.. _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)
Operator Classes
^^^^^^^^^^^^^^^^
PostgreSQL allows the specification of an *operator class* for each column of
an index (see
http://www.postgresql.org/docs/8.3/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`` dictionary are the "key" name of
the :class:`.Column`, i.e. the name used to access it from the ``.c``
collection of :class:`.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'
})
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
http://www.postgresql.org/docs/8.3/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:`.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:`.Inspector`, the :meth:`.Inspector.get_indexes`
and the :meth:`.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=True)``, the UNIQUE INDEX is **not** returned
in :attr:`.Table.indexes` when it is detected as mirroring a
:class:`.UniqueConstraint` in the :attr:`.Table.constraints` collection.
.. versionchanged:: 1.0.0 - :class:`.Table` reflection now includes
:class:`.UniqueConstraint` objects present in the :attr:`.Table.constraints`
collection; the PostgreSQL backend will no longer include a "mirrored"
:class:`.Index` construct in :attr:`.Table.indexes` if it is detected
as corresponding to a unique constraint.
Special Reflection Options
--------------------------
The :class:`.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:`.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
<http://www.postgresql.org/docs/current/static/sql-createtable.html>`_
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. In order to send and receive an ARRAY of ENUM,
use the following workaround type, which decorates the
:class:`.postgresql.ARRAY` datatype.
.. 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, for an ARRAY of JSON/JSONB we need to render the
appropriate CAST, however current psycopg2 drivers seem to handle the result
for ARRAY of JSON automatically, so the type is simpler::
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����( t defaultdictNi ( t exc( t schema( t sql( t util( t default( t
reflection( t compiler( t elements( t
expression( t sqltypes( t BIGINT( t BOOLEAN( t CHAR( t DATE( t FLOAT( t INTEGER( t NUMERIC( t REAL( t SMALLINT( t TEXT( t VARCHAR( t UUIDs ^(?:btree|hash|gist|gin|[\w_]+)$ss \s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER|GRANT|REVOKE|IMPORT FOREIGN SCHEMA|REFRESH MATERIALIZED VIEW|TRUNCATE)t allt analyset analyzet andt anyt arrayt ast asct
asymmetrict botht caset castt checkt collatet columnt
constraintt createt current_catalogt current_datet current_rolet current_timet current_timestampt current_userR t
deferrablet desct distinctt dot elset endt exceptt falset fetcht fort foreignt fromt grantt groupt havingt int initiallyt intersectt intot leadingt limitt localtimet localtimestampt newt nott nullt oft offt offsett oldt ont onlyt ort ordert placingt primaryt
referencest returningt selectt session_usert somet symmetrict tablet thent tot trailingt truet uniont uniquet usert usingt variadict whent wheret windowt witht
authorizationt betweent binaryt crosst current_schemat freezet fullt iliket innert ist isnullt joint leftt liket naturalt notnullt outert overt overlapst rightt similart verbosei� i� i� i� i� i� i i i i i� i� i� t BYTEAc B s e Z d Z RS( R| ( t __name__t
__module__t __visit_name__( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR| 7 s t DOUBLE_PRECISIONc B s e Z d Z RS( R� ( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� ; s t INETc B s e Z d Z RS( R� ( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� ? s t CIDRc B s e Z d Z RS( R� ( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� F s t MACADDRc B s e Z d Z RS( R� ( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� M s t MONEYc B s e Z d Z d Z RS( sC Provide the PostgreSQL MONEY type.
.. versionadded:: 1.2
R� ( R} R~ t __doc__R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� T s t OIDc B s e Z d Z d Z RS( sC Provide the PostgreSQL OID type.
.. versionadded:: 0.9.5
R� ( R} R~ R� R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� _ s t REGCLASSc B s e Z d Z d Z RS( sH Provide the PostgreSQL REGCLASS type.
.. versionadded:: 1.2.7
R� ( R} R~ R� R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� j s t TIMESTAMPc B s e Z e d d � Z RS( c C s& t t | � j d | � | | _ d S( Nt timezone( t superR� t __init__t precision( t selfR� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� v s N( R} R~ t Falset NoneR� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� u s t TIMEc B s e Z e d d � Z RS( c C s& t t | � j d | � | | _ d S( NR� ( R� R� R� R� ( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� | s N( R} R~ R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� { s t INTERVALc B sV e Z d Z d Z e Z d d d � Z e d � � Z e
d � � Z e
d � � Z RS( s� PostgreSQL INTERVAL type.
The INTERVAL type may not be supported on all DBAPIs.
It is known to work on psycopg2 and not pg8000 or zxjdbc.
R� c C s | | _ | | _ 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� t fields( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s c K s t d | j � S( NR� ( R� t second_precision( t clst intervalt kw( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt adapt_emulated_to_native� s c C s t j S( N( R
t Interval( R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _type_affinity� s c C s t j S( N( t dtt timedelta( R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt python_type� s N(
R} R~ R� R t Truet nativeR� R� t classmethodR� t propertyR� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s t BITc B s e Z d Z d e d � Z RS( R� c C s. | s | p d | _ n | | _ | | _ d S( Ni ( t lengtht varying( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s N( R} R~ R R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s R c B s2 e Z d Z d Z e d � Z d � Z d � Z RS( s
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 may not be supported on all DBAPIs.
It is known to work on psycopg2 and not pg8000.
R c C s. | r! t d k r! t d � � n | | _ 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.
s= This version of Python does not support the native UUID type.N( t _python_UUIDR� t NotImplementedErrort as_uuid( R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s c C s | j r d � } | Sd Sd S( Nc S s" | d k r t j | � } n | S( N( R� R t text_type( t value( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt process� s ( R� R� ( R� t dialectR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt bind_processor� s c C s | j r d � } | Sd Sd S( Nc S s | d k r t | � } n | S( N( R� R� ( R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s ( R� R� ( R� R� t coltypeR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt result_processor� s ( R} R~ R� R R� R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR � s
t TSVECTORc B s e Z d Z d Z RS( 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 ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s t ENUMc B s� e Z d Z e Z d � Z e d � � Z d
e d � Z d
e d � Z
d � Z e d � Z
e d � Z e d � Z e d � Z RS( 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:`.Table.create` and :meth:`.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:`.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 O s2 | j d t � | _ t t | � j | | � d S( s Construct 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.
t create_typeN( t popR� R� R� R� R� ( R� t enumsR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� Y s c K s� | j d | j � | j d | j � | j d | j � | j d | j � | j d | j � | j d t � | j d | j � | | � S( sb Produce a PostgreSQL native :class:`.postgresql.ENUM` from plain
:class:`.Enum`.
t validate_stringst nameR t inherit_schemat metadatat _create_eventst values_callable( t
setdefaultR� R� R R� R� R� R� ( R� t implR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� w s c C sS | j j s d S| s9 | j j | | j d | j � rO | j t | � � n 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`,
:class:`.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.
NR ( R� t supports_native_enumt has_typeR� R t executet CreateEnumType( R� t bindt
checkfirst( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR' � s
c C sR | j j s d S| s8 | j j | | j d | j �rN | j t | � � n 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`,
:class:`.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� R� R R� t DropEnumType( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt drop� s
c C s� | j s
t Sd | k r� | d } d | j k rB | j d } n t � } | j d <| j | j f | k } | j | j | j f � | St Sd S( 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� t memot setR R� t addR� ( R� R� R� t
ddl_runnert pg_enumst present( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _check_for_name_in_memos� s
c K sS | s6 | j rO | j d t � rO | j | | � rO | j d | d | � n d S( Nt _is_metadata_operationR� R� ( R� t getR� R� R' ( R� t targetR� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _on_table_create� s
c K sM | j rI | j d t � rI | j | | � rI | j d | d | � n d S( NR� R� R� ( R� R� R� R� R� ( R� R� R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _on_table_drop� s
c K s/ | j | | � s+ | j d | d | � n d S( NR� R� ( R� R' ( R� R� R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _on_metadata_create� s c K s/ | j | | � s+ | j d | d | � n d S( NR� R� ( R� R� ( R� R� R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _on_metadata_drop� s N( R} R~ R� R� t native_enumR� R� R� R� R' R� R� R� R� R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� s L t integert bigintt smallints character varyingt characters "char"R� t textt numerict floatt realt inett cidrt uuidt bits bit varyingt macaddrt moneyt oidt regclasss double precisiont timestamps timestamp with time zones timestamp without time zones time with time zones time without time zonet datet timet byteat booleanR� t tsvectort
PGCompilerc B s� e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c K s d | j | | � S( Ns ARRAY[%s]( t visit_clauselist( R� t elementR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_array s c K s, d | j | j | � | j | j | � f S( Ns %s:%s( R� t startt stop( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_slice s c K s t | d <| j | d | � S( Nt eager_groupings -> ( R� t _generate_generic_binary( R� Rh t operatorR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_json_getitem_op_binary s
c K s t | d <| j | d | � S( NR� s #> ( R� R� ( R� Rh R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt! visit_json_path_getitem_op_binary s
c K s, d | j | j | � | j | j | � f S( Ns %s[%s]( R� Rr Ry ( R� Rh R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_getitem_binary s c K s, d | j | j | � | j | j | � f S( Ns %s ORDER BY %s( R� R� t order_by( R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_aggregate_order_by& s c K s� d | j k rc | j | j d t j � } | rc d | j | j | � | | j | j | � f Sn d | j | j | � | j | j | � f S( Nt postgresql_regconfigs %s @@ to_tsquery(%s, %s)s %s @@ to_tsquery(%s)( t modifierst render_literal_valueR
t
STRINGTYPER� Rr Ry ( R� Rh R� R� t regconfig( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_match_op_binary, s c K sd | j j d d � } d | j | j | � | j | j | � f | r_ d | j | t j � n d S( Nt escapes %s ILIKE %ss ESCAPE t ( R� R� R� R� Rr Ry R� R
R� ( R� Rh R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_ilike_op_binary< s c K sd | j j d d � } d | j | j | � | j | j | � f | r_ d | j | t j � n d S( NR� s %s NOT ILIKE %ss ESCAPE R ( R� R� R� R� Rr Ry R� R
R� ( R� Rh R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_notilike_op_binaryH s c s0 d d j � f d � | p$ t � g D� � f S( Ns SELECT %s WHERE 1!=1s , c 3 s: | ]0 } d � j j j | j r* t � n | � Vq d S( s CAST(NULL AS %s)N( R� t
type_compilerR� t _isnullR ( t .0t type_( R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>Y s ( Rq R ( R� t
element_types( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_empty_set_exprS s c C s@ t t | � j | | � } | j j r< | j d d � } n | S( Ns \s \\( R� R� R� R� t _backslash_escapest replace( R� R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� a s c K s d | j j | � S( Ns
nextval('%s')( t preparert format_sequence( R� t seqR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_sequenceh s c K s� d } | j d k r5 | d | j | j | � 7} n | j d k r� | j d k r` | d 7} n | d | j | j | � 7} n | S( NR s
LIMIT s
LIMIT ALLs OFFSET ( t
_limit_clauseR� R� t _offset_clause( R� RT R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt limit_clausek s
c C s0 | j � d k r( t j d | � � n d | S( Nt ONLYs Unrecognized hint: %rs ONLY ( t upperR t CompileError( R� t sqltextRX t hintt iscrud( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt format_from_hint_textu s c K s� | j t k r� | j t k r" d St | j t t f � rq d d j g | j D] } | j | | � ^ qM � d Sd | j | j | � d Sn d Sd S( Ns DISTINCT s
DISTINCT ON (s , s ) R ( t _distinctR� R� t
isinstancet listt tupleRq R� ( R� RT R� t col( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_select_precolumnsz s 7 c s� | j j r* | j j r! d } qE d } n | j j r? d } n d } | j j r� t j � } x* | j j D] } | j t j | � � qj W| d d j � � f d � | D� � 7} n | j j
r� | d 7} n | j j r� | d 7} n | S(
Ns FOR KEY SHAREs
FOR SHAREs FOR NO KEY UPDATEs FOR UPDATEs OF s , c 3 s- | ]# } � j | d t d t � �Vq d S( t ashintt
use_schemaN( R� R� R� ( R RX ( R� R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>� s s NOWAITs SKIP LOCKED( t _for_update_argt readt key_shareRH R t
OrderedSett updatet sql_utilt surface_selectables_onlyRq t nowaitt skip_locked( R� RT R� t tmpt tablest c( ( R� R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt for_update_clause� s&
c C sH g t j | � D]! } | j d | t t i � ^ q } d d j | � S( Ns
RETURNING s , ( R t _select_iterablest _label_select_columnR� R� R� Rq ( R� t stmtt returning_colsR, t columns( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt returning_clause� s 4c K s� | j | j j d | � } | j | j j d | � } t | j j � d k r} | j | j j d | � } d | | | f Sd | | f Sd S( Ni i i s SUBSTRING(%s FROM %s FOR %s)s SUBSTRING(%s FROM %s)( R� t clausest len( R� t funcR� t sR� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_substring_func� s c s� | j d k r d | j } nv | j d k r� d d j � f d � | j D� � } | j d k r� | d � j | j d t d t �7} q� n d } | S( Ns ON CONSTRAINT %ss (%s)s , c 3 sN | ]D } t | t j � r- � j j | � n � j | d t d t �Vq d S( t
include_tableR N( R R t string_typesR t quoteR� R� ( R R, ( R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>� s s WHERE %sR9 R R ( t constraint_targetR� t inferred_target_elementsRq t inferred_target_whereclauseR� R� ( R� t clauseR� t target_text( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _on_conflict_target� s c K s( | j | | � } | r d | Sd Sd S( Ns ON CONFLICT %s DO NOTHINGs ON CONFLICT DO NOTHING( RA ( R� t on_conflictR� R@ ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_on_conflict_do_nothing� s c K sH | } | j | | � } g } t | j � } | j d d } | j j } x� | D]� } | j }
|
| k rQ | j |
� } t j | � r� t j
d | d | j �} n9 t
| t j
� r� | j j r� | j � } | j | _ n | j | j � d t �} | j j |
� }
| j d |
| f � qQ qQ W| r�t j d | j j j d j d � | D� � f � x� | j � D]z \ } } t
| t j � r�| j j | � n | j | d t �}
| j t j | � d t �} | j d |
| f � qrWn d j | � } | j d k r:| d | j | j d
t d t �7} n d | | f S( Ni����t
selectableR R s %s = %ssF Additional column names not matching any column keys in table '%s': %ss , c s s | ] } d | Vq d S( s '%s'N( ( R R, ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr> s s WHERE %sR9 s ON CONFLICT %s DO UPDATE SET %s( RA t dictt update_values_to_sett stackRX R, t keyR� R t _is_literalt
BindParameterR� t typeR R t _cloneR� t
self_groupR� R R; t appendR t warnt statementR� Rq t itemsR: t _literal_as_bindst update_whereclauseR� ( R� RB R� R? R@ t action_set_opst set_parameterst insert_statementt colsR, t col_keyR� t
value_textt key_textt kt vt action_text( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_on_conflict_do_update� sF
$ c s' d d j � � � f d � | D� � S( Ns FROM s , c 3 s- | ]# } | j � d t d � � �Vq d S( t asfromt fromhintsN( t _compiler_dispatchR� ( R t t( t
from_hintsR� R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>! s ( Rq ( R� t update_stmtt
from_tablet extra_fromsRc R� ( ( Rc R� R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt update_from_clause s c s' d d j � � � f d � | D� � S( s9 Render the DELETE .. USING clause specific to PostgreSQL.s USING s , c 3 s- | ]# } | j � d t d � � �Vq d S( R_ R` N( Ra R� ( R Rb ( Rc R� R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>* s ( Rq ( R� t delete_stmtRe Rf Rc R� ( ( Rc R� R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt delete_extra_from_clause% s ( R} R~ R� R� R� R� R� R� R� R R R R� R R R R R- R3 R8 RA RC R^ Rg Ri ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� s.
= t
PGDDLCompilerc B sP e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c K sf | j j | � } | j j | j � } t | t j � rE | j } n | j r� | | j
j k r� | j j s t | t j
� r� | j d k s� t | j t j � r� | j j r� t | t j � r� | d 7} qLt | t j
� r� | d 7} qL| d 7} nR | d | j j j | j d | �7} | j | � } | d k rL| d | 7} n | j sb| d 7} n | S( Ns
BIGSERIALs SMALLSERIALs SERIALt t type_expressions DEFAULT s NOT NULL( R t
format_columnRK t dialect_implR� R R
t
TypeDecoratorR� t primary_keyRX t _autoincrement_columnt supports_smallserialt SmallIntegerR R� R t Sequencet optionalt
BigIntegerR R� t get_column_default_stringt nullable( R� R% t kwargst colspect impl_typeR ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_column_specification0 s0
c C s d | j j | j � S( Ns COMMENT ON TABLE %s IS NULL( R t format_tableR� ( R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_drop_table_commentX s c s? | j } d � j j | � d j � f d � | j D� � f S( Ns CREATE TYPE %s AS ENUM (%s)s , c 3 s0 | ]& } � j j t j | � d t �Vq d S( t
literal_bindsN( t sql_compilerR� R t literalR� ( R t e( R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>c s ( R� R t format_typeRq R� ( R� R' R ( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_create_enum_type] s c C s | j } d | j j | � S( Ns DROP TYPE %s( R� R R� ( R� R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_drop_enum_typeh s c C sZ | j } | j } | j | � d } | j r; | d 7} n | d 7} | j j rx | j d d } | rx | d 7} qx n | d | j | d t �| j | j
� f 7} | j d d } | r� | d
| j j | t � j
� 7} n | j d d } | d d
j g | j D]u } | j j t | t j � s8| j � n | d t d t �t | d � ry| j | k ryd | | j n d ^ q � 7} | j d d } | r�| d d
j g | j � D] }
d |
^ q�� 7} n | j d d } | r
| d | j | � 7} n | j d d } | d k rV| j j | d t d t �}
| d |
7} n | S( Ns CREATE s UNIQUE s INDEX t
postgresqlt concurrentlys
CONCURRENTLY s %s ON %s t include_schemaR` s USING %s t opss (%s)s , R9 R RH Rk R Re s
WITH (%s)s %s = %st
tablespaces TABLESPACE %sRc s WHERE ( R R� t _verify_index_tableR^ R� t# _supports_create_index_concurrentlyt dialect_optionst _prepared_index_nameR� R} RX t validate_sql_phraset IDX_USINGt lowerRq t expressionsR� R� R R t ColumnClauseRM R� t hasattrRH RQ R; R� ( R� R' R t indexR� R� R` R� t exprt
withclauset storage_parametert tablespace_namet whereclauset where_compiled( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_create_indexm sN
�( c C s_ | j } d } | j j rB | j d d } | rB | d 7} qB n | | j | d t �7} | S( Ns
DROP INDEX R� R� s
CONCURRENTLY R� ( R� R� t! _supports_drop_index_concurrentlyR� R� R� ( R� R� R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_drop_index� s c K s d } | j d k r2 | d | j j | � 7} n g } xJ | j D]? \ } } } t | d <| j d | j j | | � | f � qB W| d | j j | j
t � j � d j
| � f 7} | j d k r� | d | j j | j d t �7} n | | j | � 7} | S( NR s CONSTRAINT %s R9 s
%s WITH %ss EXCLUDE USING %s (%s)s , s WHERE (%s)R ( R� R� R t format_constraintt
_render_exprsR� RN R� R� R� R` R� R� Rq Rc R� t define_constraint_deferrability( R� R& R� R� R R� R� t op( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_exclude_constraint� s$
$ c s] g } | j d } | j d � } | d k r� t | t t f � sO | f } n | j d d j � f d � | D� � d � n | d r� | j d | d � n | d t k r� | j d
� n | d t k r� | j d � n | d r | d j
d
d � j � } | j d | � n | d rP| d } | j d � j j
| � � n d j | � S( NR� t inheritss
INHERITS ( s , c 3 s! | ] } � j j | � Vq d S( N( R R; ( R R� ( R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>� s s )t partition_bys
PARTITION BY %st with_oidss
WITH OIDSs
WITHOUT OIDSt on_committ _Rk s
ON COMMIT %sR� s
TABLESPACE %sR ( R� R� R� R R R RN Rq R� R� R
R R R; ( R� RX t
table_optst pg_optsR� t on_commit_optionsR� ( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt post_create_table� s,
+
(
R} R~ R| R~ R� R� R� R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRj / s ( I
t PGTypeCompilerc B s e Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d
� Z d � Z
d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_TSVECTOR s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_INET s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_CIDR s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_MACADDR s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_MONEY s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_OID s c K s d S( NR� ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_REGCLASS s c K s# | j s
d Sd i | j d 6Sd S( NR s FLOAT(%(precision)s)R� ( R� ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_FLOAT s c K s d S( Ns DOUBLE PRECISION( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_DOUBLE_PRECISION s c K s d S( NR ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_BIGINT s c K s d S( Nt HSTORE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_HSTORE! s c K s d S( Nt JSON( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_JSON$ s c K s d S( Nt JSONB( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_JSONB' s c K s d S( Nt INT4RANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_INT4RANGE* s c K s d S( Nt INT8RANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_INT8RANGE- s c K s d S( Nt NUMRANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_NUMRANGE0 s c K s d S( Nt DATERANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_DATERANGE3 s c K s d S( Nt TSRANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_TSRANGE6 s c K s d S( Nt TSTZRANGE( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_TSTZRANGE9 s c K s | j | | � S( N( t visit_TIMESTAMP( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_datetime< s c K sD | j s | j j r0 t t | � j | | � S| j | | � Sd S( N( R� R� R� R� R� t
visit_enumt
visit_ENUM( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� ? s c K s | j j j | � S( N( R� t identifier_preparerR� ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� E s c K sF d t | d d � d k r( d | j n d | j r: d p= d d f S( Ns TIMESTAMP%s %sR� s (%d)R t WITHt WITHOUTs
TIME ZONE( t getattrR� R� R� ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� H s %c K sF d t | d d � d k r( d | j n d | j r: d p= d d f S( Ns TIME%s %sR� s (%d)R R� R� s
TIME ZONE( R� R� R� R� ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_TIMEP s %c K sP d } | j d k r) | d | j 7} n | j d k rL | d | j 7} n | S( NR� Rk s (%d)( R� R� R� ( R� R R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_INTERVALX s c K sF | j r5 d } | j d k rB | d | j 7} qB n
d | j } | S( Ns BIT VARYINGs (%d)s BIT(%d)( R� R� R� ( R� R R� t compiled( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_BIT` s
c K s d S( NR ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
visit_UUIDi s c K s | j | | � S( N( t visit_BYTEA( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_large_binaryl s c K s d S( NR| ( ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� o s c K sK | j | j � } t j d d d | j d k r9 | j n d | d d �S( Ns ((?: COLLATE.*)?)$s %s\1s []i t count( R� t item_typet ret subt
dimensionsR� ( R� R R� Rn ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_ARRAYr s ( R} R~ R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s< t PGIdentifierPreparerc B s# e Z e Z d � Z e d � Z RS( c C s9 | d | j k r5 | d d !j | j | j � } n | S( Ni i i����( t
initial_quoteR
t escape_to_quotet escape_quote( R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _unquote_identifier� s
c C sv | j s t j d � � n | j | j � } | j | � } | j rr | rr | d k rr | j | � d | } n | S( Ns% PostgreSQL ENUM type requires a name.t .( R� R R R; t schema_for_objectt omit_schemaR� t quote_schema( R� R R R� t effective_schema( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s
( R} R~ t RESERVED_WORDSt reserved_wordsR� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s t PGInspectorc B sD e Z d � Z d d � Z d d � Z d d � Z d d d � Z RS( c C s t j j | | � d S( N( R t InspectorR� ( R� t conn( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s c C s" | j j | j | | d | j �S( s( Return the OID for the given table name.t
info_cache( R� t
get_table_oidR� R� ( R� t
table_nameR ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s c C s% | p | j } | j j | j | � S( sK Return 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
( t default_schema_nameR� t _load_enumsR� ( R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_enums� s c C s% | p | j } | j j | j | � S( s Return a list of FOREIGN TABLE names.
Behavior is similar to that of :meth:`.Inspector.get_table_names`,
except that the list is limited to those tables that report a
``relkind`` value of ``f``.
.. versionadded:: 1.0.0
( R� R� t _get_foreign_table_namesR� ( R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_foreign_table_names� s
t plaint materializedc C s% | j j | j | d | j d | �S( 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
R� t include( R� t get_view_namesR� R� ( R� R R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s N( R� R� ( R} R~ R� R� R� R� R� R� ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s
R� c B s e Z d Z RS( t create_enum_type( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s R� c B s e Z d Z RS( t drop_enum_type( R} R~ R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s t PGExecutionContextc B s# e Z d � Z d � Z d � Z RS( c C s# | j d | j j j | � | � S( Ns select nextval('%s')( t _execute_scalarR� R� R ( R� R
R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
fire_sequence� s c C s� | j r~| | j j k r~| j rM | j j rM | j d | j j | j � S| j d k st | j j
r~| j j r~y
| j } Wn� t
k
r| j j } | j } | d d t d d t | � � !} | d d t d d t | � � !} d | | f } | | _ } n X| j d k r6| j j | j � } n d } | d k r[d | | f } n
d | f } | j | | j � Sn t t | � j | � S( Ns select %si i s %s_%s_seqs select nextval('"%s"."%s"')s select nextval('"%s"')( Rp RX Rq t server_defaultt has_argumentR� t argRK R R� t is_sequenceRu t _postgresql_seq_namet AttributeErrorR� t maxR5 t
connectionR� R� R� t get_insert_default( R� R% t seq_namet tabR R� R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR � s4
$$
c C s
t j | � S( N( t AUTOCOMMIT_REGEXPt match( R� RP ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt should_autocommit_text s ( R} R~ R� R R ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� � s .t PGDialectc B s& e Z d Z e Z d Z e Z e Z e Z e Z e Z
e Z e Z e
Z e Z e Z e
Z e Z d Z e Z e Z e Z e Z e Z e Z e Z e Z! d6 Z# e$ j% i e
d 6d6 d 6i d 6e
d 6i d 6d6 d 6f e$ j& i e
d 6d6 d 6d6 d
6d6 d 6d6 d 6d6 d
6f g Z' d7 Z( e Z) e Z* e Z+ d6 d6 d6 d � Z, d � Z- d � Z. e/ d d d d g � Z0 d � Z1 d � Z2 d � Z3 d � Z4 e e
d � Z5 e e
d � Z6 d � Z7 d � Z8 d � Z9 d6 d � Z: d6 d � Z; d6 d! � Z< d" � Z= e> j? d6 d# � � Z@ e> j? d$ � � ZA e> j? d6 d% � � ZB e> j? d6 d& � � ZC e> j? d6 d8 d) � � ZD e> j? d6 d* � � ZE e> j? d6 d+ � � ZF d, � ZG e> j? d6 d- � � ZH e> j? d6 e
d. � � ZI d/ � ZJ e> j? d0 � � ZK e> j? d6 d1 � � ZL e> j? d6 d2 � � ZM e> j? d6 d3 � � ZN d6 d4 � ZO d5 � ZP RS(9 R� i? t pyformatR` Rc R� R� Re R� t ignore_search_pathR� R� R� R� t postgresql_ignore_search_pathc K s2 t j j | | � | | _ | | _ | | _ d S( N( R t DefaultDialectR� t isolation_levelt _json_deserializert _json_serializer( R� R t json_serializert json_deserializerRy ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� a s c C s� t t | � j | � | j d k o7 | j j d t � | _ | j d k | _ | j s� | j j
� | _ | j j t j
d � | j j t d � n | j d
k | _ | j d k p� | j d � d k | _ | j d k | _ | j d
k | _ d S( Ni i t implicit_returningi i s show standard_conforming_stringsRI ( i i ( i i ( i i ( i i ( i i ( i i ( R� R
t
initializet server_version_infot __dict__R� R� R R� t colspecst copyR� R
t EnumR� R� Rr t scalarR R� R� ( R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR m s" c s* � j d k r" � f d � } | Sd Sd S( Nc s � j | � j � d S( N( t set_isolation_levelR ( R� ( R� ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt connect� s ( R R� ( R� R ( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
on_connect� s t SERIALIZABLEs READ UNCOMMITTEDs READ COMMITTEDs REPEATABLE READc C s� | j d d � } | | j k rO t j d | | j d j | j � f � � n | j � } | j d | � | j d � | j � d S( NR� Rk sL Invalid value '%s' for isolation_level. Valid isolation levels for %s are %ss , s= SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL %st COMMIT( R
t _isolation_lookupR t
ArgumentErrorR� Rq t cursorR� t close( R� R t levelR& ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR � s %
c C s= | j � } | j d � | j � d } | j � | j � S( Ns show transaction isolation leveli ( R& R� t fetchoneR' R ( R� R R& t val( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_isolation_level� s
c C s | j | j � d S( N( t do_beginR ( R� R t xid( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt do_begin_twophase� s c C s | j d | � d S( Ns PREPARE TRANSACTION '%s'( R� ( R� R R- ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt do_prepare_twophase� s c C sa | rM | r | j d � n | j d | � | j d � | j | j � n | j | j � d S( Nt ROLLBACKs ROLLBACK PREPARED '%s't BEGIN( R� t do_rollbackR ( R� R R- t is_preparedt recover( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt do_rollback_twophase� s
c C sa | rM | r | j d � n | j d | � | j d � | j | j � n | j | j � d S( NR0 s COMMIT PREPARED '%s'R1 ( R� R2 R t do_commit( R� R R- R3 R4 ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt do_commit_twophase� s
c C s3 | j t j d � � } g | D] } | d ^ q S( Ns! SELECT gid FROM pg_prepared_xactsi ( R� R R� ( R� R t resultsett row( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt do_recover_twophase� s c C s
| j d � S( Ns select current_schema()( R ( R� R ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _get_default_schema_name� s c C s[ d } | j t j | � j t j d t j | j � � d t j �� � } t
| j � � S( Ns= select nspname from pg_namespace where lower(nspname)=:schemaR R ( R� R R� t
bindparamst bindparamR R� R� R
t Unicodet boolt first( R� R R t queryR& ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
has_schema� s c C s� | d k rN | j t j d � j t j d t j | � d t j �� � } n` | j t j d � j t j d t j | � d t j �t j d t j | � d t 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 st select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where n.nspname=:schema and relname=:nameR ( R� R� R R� R< R= R R� R
R> R? R@ ( R� R R� R R& ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt has_table� s( c C s� | d k rN | j t j d � j t j d t j | � d t j �� � } n` | j t j d � j t j d t j | � d t j �t j d t j | � d t 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=current_schema() and relname=:nameR� R s� 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 R� R< R= R R� R
R> R? R@ ( R� R t
sequence_nameR R& ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt has_sequence
s( c C s� | d k r$ d } t j | � } n d } t j | � } | j t j d t j | � d t j �� } | d k r� | j t j d t j | � d t j �� } 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)
)
t typnameR t nspname( R� R R� R< R= R R� R
R> R� R? R ( R� R t type_nameR RA R& ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� <
s ! $c C s~ | j d � j � } t j d | � } | s@ t d | � � n t g | j d d d � D] } | d k rY t | � ^ qY � S( Ns select version()sQ .*(?:PostgreSQL|EnterpriseDB) (\d+)\.?(\d+)?(?:\.(\d+))?(?:\.\d+)?(?:devel|beta)?s, Could not determine version from string '%s'i i i ( R� R R� R t AssertionErrorR R; R� t int( R� R R\ t mt x( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _get_server_version_info^
s c
K s� d } | d k r d } n d } d | } t j | � } | d k rX t j | � } n t j | � j d t j � } | j d t j � } | r� | j t j
d d t j �� } n | j | d | d | �} | j � } | d k r� t
j | � � 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.
s n.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')
R� R� R R N( R� R R� R R� R< R
R> R2 t IntegerR= R� R R t NoSuchTableError(
R� R R� R R� t table_oidt schema_where_clauseRA R7 R, ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� k
s$ $ c K sA | j t j d � j d t j � � } g | D] \ } | ^ q. S( NsO SELECT nspname FROM pg_namespace WHERE nspname NOT LIKE 'pg_%' ORDER BY nspnameRG ( R� R R� R2 R
R> ( R� R R� t resultR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_schema_names�
s
c K s\ | j t j d � j d t j � d | d k r6 | n | j �} g | D] \ } | ^ qI S( 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')t relnameR ( R� R R� R2 R
R> R� R� ( R� R R R� RR R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_table_names�
s c K s\ | j t j d � j d t j � d | d k r6 | n | j �} g | D] \ } | ^ qI S( 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'RT R ( R� R R� R2 R
R> R� R� ( R� R R R� RR R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� �
s R� R� c
K s� i d d 6d d 6} y* g t j | � D] } | | ^ q' } Wn$ t k
rd t d | f � � n X| sz t d � � n | j t j d d j d � | D� � � j d
t j
� d | d k r� | n | j �} g | D] \ } | ^ q� S( NR\ R� RK R� s_ include %r unknown, needs to be a sequence containing one or both of 'plain' and 'materialized'sZ empty 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 s s | ] } d | Vq d S( s '%s'N( ( R t elem( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>�
s RT R (
R t to_listt KeyErrort
ValueErrorR� R R� Rq R2 R
R> R� R� (
R� R R R� R� t include_kindt it kindsRR R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� �
s" *
c K sL | j t j d � j d t j � d | d k r6 | n | j d | �} | 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')t view_defR t view_name( R R R� R2 R
R> R� R� ( R� R R^ R R� R] ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_view_definition�
s c
K s" | j | | | d | j d � �} d } t j | � j t j d d t j �� j d t j d t j � } | j
| d | �} | j � } | j | � }
t
d � | j | d d �D� � } g } xT | D]L \ }
} } } } } } | j |
| | | |
| | | � } | j | � q� W| S(
NR� s�
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.attnum, a.attrelid as table_oid,
pgd.description as comment
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
RP R t attnameR c s sF | ]< } | d r& | d f | f n | d | d f | f Vq d S( t visibleR� R N( ( R t rec( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr> s R t *( R� R� R R� R< R= R
RN R2 R> R� t fetchallt
_load_domainsRE R� t _get_column_infoRN ( R� R R� R R� RP t SQL_COLSR7 R, t rowst domainsR� R2 R� R� t default_Ru t attnumt commentt column_info( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_columns�
s4 c
C s� d � } t j d d | � }
| |
� \ }
} t t j |
� � } | }
t j d | � } | rv | j d � } n t j d | � } | r� | j d � r� t t j d | j d � � � } n d* } i } |
d k r| r| j d � \ } } t | � t | � f } qld+ } nT|
d
k r-d, } n?|
d k rBd- } n*|
d. k rzt | d <| rqt | � | d <n d/ } n� |
d0 k r�t
| d <| r�t | � | d <n d1 } n� |
d k r�t | d <| r�t | � f } qld2 } n� |
j d � rTt j d |
t j
� } | r)t | � | d <n | rE| j d � | d <n d }
d3 } n | rlt | � f } n x� t rm|
| j k r�| j |
} Pqo| | k r�| | } t } | d | d <| d s�| d | d <n t | d � } Pqo| | k rc| | } | d }
| |
� \ }
} t t j |
� � } | d }
| d ro| ro| d } qoqoqod } PqoW| r�| | | � } | r�| j d | � } q�n t j d! |
| f � t j } t
} | d k rut j d" | � } | d k rut | j t j � rt } n | } d# | j d$ � k rr| d k rr| j d � d% | d# | j d$ � | j d& � } qrqun t d | d' | d |
d | d( | d) | � } | S(4 Nc S s" t j d d | � | j d � f S( Ns \[\]$R s []( R� R� t endswith( t attype( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _handle_array_type2 s s \(.*\)R s \(([\d,]+)\)i s \((.*)\)s \s*,\s*R� t ,s double precisioni5 R� s timestamp with time zones time with time zoneR� R� s timestamp without time zones time without time zoneR� s bit varyingR� R� s
interval (.+)R� R� Ra R t labelsRp Rx R t _arrays* Did not recognize type '%s' of column '%s's (nextval\(')([^']+)('.*$)R� i s "%s"i RK t
autoincrementRl ( ( ( i5 ( ( s timestamp with time zones time with time zone( ( s timestamp without time zones time without time zoneR� ( ( ( ( R� R� R R t quoted_token_parsert searchR; t splitRJ R� R� t
startswithR t It
ischema_namesR� R� RO R
t NULLTYPEt
issubclassR� RN RE ( R� R� R� R Ru Ri R� R Rl Rq Rp t is_arrayt enum_or_domain_keyRx t charlent argsRy t prect scalet field_matchR� t enumt domainRu R t schRm ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRf ' s� $
! > c
K s� | j | | | d | j d � �} | j d k rL d | j d d � } n d } t j | � j d t j � } | j | d | �} g | j
� D] } | d
^ q� }
d } t j | � j d t j � } | j | d | �} | j � } i |
d
6| d 6S( NR� i i sq
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
s a.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` RP i s�
SELECT conname
FROM pg_catalog.pg_constraint r
WHERE r.conrelid = :table_oid AND r.contype = 'p'
ORDER BY 1
t connamet constrained_columnsR� ( i i ( R� R� R t
_pg_index_anyR R� R2 R
R> R� Rd R (
R� R R� R R� RP t PK_SQLRb R, t rRW t PK_CONS_SQLR� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_pk_constraint� s # c K s? | j } | j | | | d | j d � �} d } t j d � } t j | � j d t j d t j � }
| j
|
d | �} g } x�| j � D]�\ }
} } t j | | � j
� } | \
} } } } } } } } } } } } } | d k r | d k rt n t } n g t j d | � D] } | j | � ^ q } | ra| | j k rX| } q�| } n9 | ry| j | � } n! | d k r�| | k r�| } n | j | � } g t j d | � D] } | j | � ^ q�} i |
d
6| d 6| d 6| d
6| d 6i | d 6| d 6| d 6| d 6| d 6d 6} | j | � q� W| S( NR� s�
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� t condefRX t
DEFERRABLEs \s*,\s*s \s*,\sR� R� t referred_schemat referred_tablet referred_columnst onupdatet ondeleteR. R> R t options( R� R� R� R� t compileR R� R2 R
R> R� Rd Rw t groupsR� R� R� Rx R� R� RN ( R� R R� R R R� R RP t FK_SQLt FK_REGEXRb R, t fkeysR� R� t conschemaRK R� R� R� R� R� R R� R� R. R> RL t fkey_d( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_foreign_keys� sT
- + +c sN | j d k r< d d j � � f d � t d d � D� � Sd � � f Sd S(
Ni i s (%s)s OR c 3 s" | ] } d � | � f Vq d S( s %s[%d] = %sN( ( R t ind( R t
compare_to( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>h s i i
s %s = ANY(%s)( i i ( R Rq t range( R� R R� ( ( R R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� _ s $c # s9 | j | | | d | j d � �} | j d) k r� d | j d* k rK d n d | j d+ k rc d n d | j d, k r{ d n d | j d d
� f } n d } t j | � j d t j d t j � } | j | d | �} t
d � � } d }
x.| j � D] } | \ } }
} } } } } } } } } | rZ| |
k rNt
j d | � n | }
q� n | r�| |
k r�t
j d | � | }
n | | k } | | } | d k r�| | d | <n | s� g | j � D] } t | j � � ^ q�| d <i } x� t | pd j � � D]| \ } } t | j � � } d- } | d @r`| d. 7} | d
@sw| d/ 7} qwn | d
@rw| d0 7} n | r| | | <qqW| r�| | d <n |
| d <| d k r�| | d <n | r�t g | D] } | j d � ^ q�� | d <n | r| d k r| | d! <qq� q� Wg } x
| j � D]� \ } � i | d" 6� d d 6g � d D] }! � d |! ^ q^d# 6}" d � k r�� d |" d <n d � k r�t � f d$ � � d j � D� � |" d% <n d � k r�� d |" j d& i � d' <n d! � k r$� d! |" j d& i � d( <n | j |" � q2W| S(1 NR� i i s�
SELECT
i.relname as relname,
ix.indisunique, ix.indexprs, ix.indpred,
a.attname, a.attnum, NULL, ix.indkey%s,
%s, %s, am.amname
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
i s ::varcharR s ix.indoption::varchart NULLi s i.reloptionss a.attnums ix.indkeys�
SELECT
i.relname as relname,
ix.indisunique, ix.indexprs, ix.indpred,
a.attname, a.attnum, c.conrelid, ix.indkey::varchar,
ix.indoption::varchar, i.reloptions, am.amname
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
RT R` RP c S s
t t � S( N( R RE ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt <lambda>� R s; Skipped unsupported reflection of expression-based index %ss7 Predicate of partial index %s ignored during reflectionRW RH i R/ t nullslastt
nullsfirstt sortingR^ t duplicates_constraintt =R� t btreet amnameR� t column_namesc 3 s1 | ]' \ } } � d � d | | f Vq d S( RW RH N( ( R R[ R� ( t idx( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys <genexpr>
s t column_sortingR� t postgresql_witht postgresql_using( i i ( i i ( i i ( i i ( ( R/ ( R� ( R� ( R� R� R R� R R� R2 R
R> R� R R� Rd R RO Rx RJ t stript enumerateRE RQ R� RN (# R� R R� R R� RP t IDX_SQLRb R, t indexest sv_idx_nameR9 t idx_nameR^ R� t prdR t col_numt conrelidt idx_keyt
idx_optionR� R� t has_idxR� R[ R� t col_idxt col_flagst col_sortingt optionRR R� R[ t entry( ( R� sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_indexesm s�
'
/
, ) c K s | j | | | d | j d � �} d } t j | � j d t j � } | j | d | �} t d � � } xB | j � D]4 }
| |
j
} |
j | d <|
j | d |
j
<qy Wg | j � D]? \ } } i | d 6g | d D] }
| d |
^ q� d 6^ q� S(
NR� s�
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'
t col_nameRP c S s
t t � S( N( R RE ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� A
R RH RW R� R� ( R� R� R R� R2 R
R> R� R Rd R� RH R� R� RQ ( R� R R� R R� RP t
UNIQUE_SQLRb R, t uniquesR9 t ucR� R[ ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_unique_constraints&
s
c K sY | j | | | d | j d � �} d } | j t j | � d | �} i | j � d 6S( NR� s�
SELECT
pgd.description as table_comment
FROM
pg_catalog.pg_description pgd
WHERE
pgd.objsubid = 0 AND
pgd.objoid = :table_oid
RP R� ( R� R� R� R R� R ( R� R R� R R� RP t COMMENT_SQLR, ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_table_commentL
s
c K s� | j | | | d | j d � �} d } | j t j | � d | �} d � } g | j � D]& \ } }
i | d 6| |
� d 6^ q^ S( NR� s
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'
RP c S s: t j d | � } | s- t j d | � d S| j d � S( Ns ^CHECK *\(\((.+)\)\)$s) Could not parse CHECK constraint text: %rR i ( R� R R RO R; ( t srcRK ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt
match_consu
s
R� R ( R� R� R� R R� Rd ( R� R R� R R� RP t CHECK_SQLR, R� R� R� ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_check_constraints_
s c C sj | p | j } | j s i Sd } | d k r; | d 7} n | d 7} t j | � j d t j d t j � } | d k r� | j d | � } n | j | � } g } i } x� | j � D]� } | d | d f } | | k r� | | d j
| d � q� i | d d 6| d d 6| d
d
6g d 6| | <}
| d d k rU|
d j
| d � 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'
Rc s AND n.nspname = :schema s ORDER BY "schema", "name", e.oidR` t labelR R� Rs Ra ( R� R� R R� R2 R
R> R< R� Rd RN R� ( R� R R t SQL_ENUMSR7 R, R� t enum_by_nameR� RH t enum_rec( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR� �
s6
c C s� d } t j | � j d t j � } | j | � } i } x� | j � D]z } t j d | d � j d � } | d r� | d f } n | d | d f } i | d 6| d d 6| d
d
6| | <qF W| 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'
R` s ([^\(]+)Rp i Ra R� R Rx R (
R R� R2 R
R> R� Rd R� Rw R; ( R� R t SQL_DOMAINSR7 R, Ri R� Rp RH ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRe �
s
N( R ( R� R� (Q R} R~ R� R� t supports_altert max_identifier_lengtht supports_sane_rowcountR� t supports_native_booleanRr t supports_sequencest sequences_optionalt" preexecute_autoincrement_sequencesR� t postfetch_lastrowidt supports_commentst supports_default_valuest supports_empty_insertt supports_multivalues_insertt default_paramstyleR{ R R� t statement_compilerRj t ddl_compilerR� R R� R R� t execution_ctx_clsR� t inspectorR� R R t Indext Tablet construct_argumentst reflection_optionsR R� R� R� R R! R� R$ R R+ R. R/ R5 R7 R: R; RB RC RE R� RM R t cacheR� RS RU R� R� R_ Rn Rf R� R� R� R� R� R� R� R� Re ( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR
# s�
& & "
'
D �2h �$! 4(] R� t collectionsR t datetimeR� R� R R R R R t engineR R R R R R
R& t typesR R R
R R R R R R R R R� R R� t ImportErrorR� R� Rz R� t UNICODER
R� R� t _DECIMAL_TYPESt _FLOAT_TYPESt
_INT_TYPESt LargeBinaryR| t FloatR� t
TypeEngineR� t PGInetR� t PGCidrR� t PGMacAddrR� R� R� R� R� t NativeForEmulatedt _AbstractIntervalR� t
PGIntervalR� t PGBitt PGUuidR� R R� R� R t StringR{ t SQLCompilerR� t DDLCompilerRj t GenericTypeCompilerR� t IdentifierPreparerR� R� R� t _CreateDropBaseR� R� t DefaultExecutionContextR� R R
( ( ( sV /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt <module>� s�
'
8 �
� "��@<
Mini Shell