H`Tcg@sTdZddlmZddlZddlmZmZmZmZddl m Z m Z ddlm Z m Z mZddlmZydd lmZWnek reZnXdd lmZmZmZmZmZmZmZmZmZm Z m!Z!e"d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpgfZ#dqdrfZ$dsdtdudvfZ%dwdxdydzd{d|d}fZ&d~ej'fdYZ(dej)fdYZ*dej+fdYZ,e,Z-dej+fdYZ.e.Z/dej+fdYZ0e0Z1dej+fdYZ2dej3fdYZ3dej4fdYZ4dej+fdYZ5e5Z6dej+fdYZ7e7Z8dej+fdYZeZ9dej+fdYZ:de j;fdYZ<de j;fdYZ=de j;fdYZ>de j?fdYZ@dejAej+fdYZBeBZCdejDfdYZEie5ejF6eEejD6ZGi ed6ed6ed6ed6ed6ejHd6ejHd6ed6ed6ed6e!d6e,d6e.d6ed6e7d6e7d6e0d6e2d6e*d6e3d6e3d6e3d6e4d6e4d6ed6e4d6e(d6e d6e5d6e5d6e5d6e:d6ZIde jJfdYZKde jLfdYZMde jNfdYZOde jPfdYZQde jRfdYZSdejTfdYZUdejTfdYZVde jWfdYZXde jYfdYZZdS(s; .. dialect:: postgresql :name: PostgreSQL Sequences/SERIAL ---------------- 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_isolation_level: Transaction Isolation Level --------------------------- All Postgresql dialects support setting of transaction isolation level both via a dialect-specific parameter ``isolation_level`` accepted by :func:`.create_engine`, as well as the ``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 `` for each new connection. 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`` The :mod:`~sqlalchemy.dialects.postgresql.psycopg2` and :mod:`~sqlalchemy.dialects.postgresql.pg8000` dialects also offer the special level ``AUTOCOMMIT``. .. seealso:: :ref:`psycopg2_isolation_level` :ref:`pg8000_isolation_level` .. _postgresql_schema_reflection: Remote-Schema Table Introspection and Postgresql search_path ------------------------------------------------------------ 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 `_. 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) ... 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) ... 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 `_ - 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_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 :attr:`.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 PostgresSQL 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 PostgresSQL ``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 PostgresSQL 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. 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=tbl.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' }) .. versionadded:: 0.7.2 ``postgresql_ops`` keyword argument to :class:`.Index` construct. 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. 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. i(t defaultdictNi(tsqltschematexctutil(tdefaultt reflection(tcompilert expressiont operators(ttypes(tUUID( tINTEGERtBIGINTtSMALLINTtVARCHARtCHARtTEXTtFLOATtNUMERICtDATEtBOOLEANtREALtalltanalysetanalyzetandtanytarraytastasct asymmetrictbothtcasetcasttchecktcollatetcolumnt constrainttcreatetcurrent_catalogt current_datet current_rolet current_timetcurrent_timestampt current_userRt deferrabletdesctdistincttdotelsetendtexcepttfalsetfetchtfortforeigntfromtgranttgroupthavingtint initiallyt intersecttintotleadingtlimitt localtimetlocaltimestamptnewtnottnulltoftofftoffsettoldtontonlytortordertplacingtprimaryt referencest returningtselectt session_usertsomet symmetricttabletthenttottrailingttruetuniontuniquetusertusingtvariadictwhentwheretwindowtwitht authorizationtbetweentbinarytcrosstcurrent_schematfreezetfulltiliketinnertistisnulltjointlefttliketnaturaltnotnulltoutertovertoverlapstrighttsimilartverboseiiiiiiiiiiiiitBYTEAcBseZdZRS(R|(t__name__t __module__t__visit_name__(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR|stDOUBLE_PRECISIONcBseZdZRS(R(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstINETcBseZdZRS(R(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstCIDRcBseZdZRS(R(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstMACADDRcBseZdZRS(R(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstOIDcBseZdZdZRS(sCProvide the Postgresql OID type. .. versionadded:: 0.9.5 R(R}R~t__doc__R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRst TIMESTAMPcBseZeddZRS(cCs&tt|jd|||_dS(Nttimezone(tsuperRt__init__t precision(tselfRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRsN(R}R~tFalsetNoneR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstTIMEcBseZeddZRS(cCs&tt|jd|||_dS(NR(RRRR(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRsN(R}R~RRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRstINTERVALcBs>eZdZdZddZedZedZ RS(sPostgresql INTERVAL type. The INTERVAL type may not be supported on all DBAPIs. It is known to work on psycopg2 and not pg8000 or zxjdbc. RcCs ||_dS(N(R(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRscCstd|jS(NR(Rtsecond_precision(tclstinterval((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_adapt_from_generic_intervalscCstjS(N(tsqltypestInterval(R((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_type_affinitysN( R}R~RRRRt classmethodRtpropertyR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs  tBITcBseZdZdedZRS(RcCs.|s|pd|_n ||_||_dS(Ni(tlengthtvarying(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs N(R}R~RRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRsR cBs2eZdZdZedZdZdZRS(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 cCs.|r!tdkr!tdn||_dS(sConstruct 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_UUIDRtNotImplementedErrortas_uuid(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR!s  cCs|jrd}|SdSdS(NcSs"|dk rtj|}n|S(N(RRt text_type(tvalue((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytprocess3s (RR(RtdialectR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytbind_processor1s  cCs|jrd}|SdSdS(NcSs|dk rt|}n|S(N(RR(R((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR=s (RR(RRtcoltypeR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytresult_processor;s  (R}R~RRRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR s    tTSVECTORcBseZdZdZRS(sThe :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~RR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRHst_SlicecBs eZdZejZdZRS(tslicecCsF|j|jtj|j|_|j|jtj|j|_dS(N(t_check_literaltexprR tgetitemtstarttstop(Rtslice_tsource_comparator((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR^s (R}R~RRtNULLTYPEttypeR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRZs tAnycBs#eZdZdZejdZRS(sRepresent the clause ``left operator ANY (right)``. ``right`` must be an array expression. .. seealso:: :class:`.postgresql.ARRAY` :meth:`.postgresql.ARRAY.Comparator.any` - ARRAY-bound method RcCs7tj|_tj||_||_||_dS(N(RtBooleanRRt_literal_as_bindsRrRytoperator(RRrRyR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRus (R}R~RRR teqR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRgs tAllcBs#eZdZdZejdZRS(sRepresent the clause ``left operator ALL (right)``. ``right`` must be an array expression. .. seealso:: :class:`.postgresql.ARRAY` :meth:`.postgresql.ARRAY.Comparator.all` - ARRAY-bound method RcCs7tj|_tj||_||_||_dS(N(RRRRRRrRyR(RRrRyR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs (R}R~RRR RR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR|s cBs2eZdZdZdZdZddZRS(sA Postgresql ARRAY literal. This is used to produce ARRAY literals in SQL expressions, e.g.:: from sqlalchemy.dialects.postgresql import array from sqlalchemy.dialects import postgresql from sqlalchemy import select, func stmt = select([ array([1,2]) + array([3,4,5]) ]) print stmt.compile(dialect=postgresql.dialect()) Produces the SQL:: SELECT ARRAY[%(param_1)s, %(param_2)s] || ARRAY[%(param_3)s, %(param_4)s, %(param_5)s]) AS anon_1 An instance of :class:`.array` will always have the datatype :class:`.ARRAY`. The "inner" type of the array is inferred from the values present, unless the ``type_`` keyword argument is passed:: array(['foo', 'bar'], type_=CHAR) .. versionadded:: 0.8 Added the :class:`~.postgresql.array` literal type. See also: :class:`.postgresql.ARRAY` RcKs/tt|j||t|j|_dS(N(RRRtARRAYR(Rtclausestkw((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRsc Cs>tg|D]-}tjd|d|d|jdt^q S(Nt_compared_to_operatort_compared_to_typeR^(RRt BindParameterRRtTrue(RRtobjto((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt _bind_paramscCs|S(N((Rtagainst((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt self_groupsN(R}R~RRRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs !  RcBs{eZdZdZdejjfdYZeZed edZ e dZ dZ dZdZd ZRS( s Postgresql ARRAY type. Represents values as Python lists. An :class:`.ARRAY` type is constructed given the "type" of element:: mytable = Table("mytable", metadata, Column("data", ARRAY(Integer)) ) The above type represents an N-dimensional array, meaning Postgresql will interpret values with any number of dimensions automatically. To produce an INSERT construct that passes in a 1-dimensional array of integers:: connection.execute( mytable.insert(), data=[1,2,3] ) The :class:`.ARRAY` type can be constructed given a fixed number of dimensions:: mytable = Table("mytable", metadata, Column("data", ARRAY(Integer, dimensions=2)) ) This has the effect of the :class:`.ARRAY` type specifying that number of bracketed blocks when a :class:`.Table` is used in a CREATE TABLE statement, or when the type is used within a :func:`.expression.cast` construct; it also causes the bind parameter and result set processing of the type to optimize itself to expect exactly that number of dimensions. Note that Postgresql itself still allows N dimensions with such a type. SQL expressions of type :class:`.ARRAY` have support for "index" and "slice" behavior. The Python ``[]`` operator works normally here, given integer indexes or slices. Note that Postgresql arrays default to 1-based indexing. The operator produces binary expression constructs which will produce the appropriate SQL, both for SELECT statements:: select([mytable.c.data[5], mytable.c.data[2:7]]) as well as UPDATE statements when the :meth:`.Update.values` method is used:: mytable.update().values({ mytable.c.data[5]: 7, mytable.c.data[2:7]: [1, 2, 3] }) :class:`.ARRAY` provides special methods for containment operations, e.g.:: mytable.c.data.contains([1, 2]) For a full list of special methods see :class:`.ARRAY.Comparator`. .. versionadded:: 0.8 Added support for index and slice operations to the :class:`.ARRAY` type, including support for UPDATE statements, and special array containment operations. The :class:`.ARRAY` type may not be supported on all DBAPIs. It is known to work on psycopg2 and not pg8000. See also: :class:`.postgresql.array` - produce a literal array value. Rt ComparatorcBsYeZdZdZejdZejdZdZdZ dZ dZ RS(s1Define comparison operations for :class:`.ARRAY`.cCs|jjjrdnd}t|trq|rVt|j||j||j}nt||}|j}n||7}|jj }|j |jt j |d|S(Niit result_type( RRt zero_indexest isinstanceRRRtstepRt item_typet_binary_operateR R(Rtindext shift_indexest return_type((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt __getitem__s     cCst||jd|S(sReturn ``other operator ANY (array)`` clause. Argument places are switched, because ANY requires array expression to be on the right hand-side. E.g.:: from sqlalchemy.sql import operators conn.execute( select([table.c.data]).where( table.c.data.any(7, operator=operators.lt) ) ) :param other: expression to be compared :param operator: an operator object from the :mod:`sqlalchemy.sql.operators` package, defaults to :func:`.operators.eq`. .. seealso:: :class:`.postgresql.Any` :meth:`.postgresql.ARRAY.Comparator.all` R(RR(RtotherR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR&scCst||jd|S(sReturn ``other operator ALL (array)`` clause. Argument places are switched, because ALL requires array expression to be on the right hand-side. E.g.:: from sqlalchemy.sql import operators conn.execute( select([table.c.data]).where( table.c.data.all(7, operator=operators.lt) ) ) :param other: expression to be compared :param operator: an operator object from the :mod:`sqlalchemy.sql.operators` package, defaults to :func:`.operators.eq`. .. seealso:: :class:`.postgresql.All` :meth:`.postgresql.ARRAY.Comparator.any` R(RR(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRDscKs|jjd|S(sBoolean expression. Test if elements are a superset of the elements of the argument array expression. s@>(Rtop(RRtkwargs((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytcontainsbscCs|jjd|S(sBoolean expression. Test if elements are a proper subset of the elements of the argument array expression. s<@(RR(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt contained_byhscCs|jjd|S(suBoolean expression. Test if array has elements in common with an argument array expression. s&&(RR(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytoverlapnscCsJt|tjr1|jdkr1|tjfSntjjj|||S(Ns@>s<@s&&(s@>s<@s&&( RR t custom_optopstringRRt ConcatenableRt_adapt_expression(RRtother_comparator((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRts  ( R}R~RRR RRRRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs    cCsat|trtdnt|tr9|}n||_||_||_||_dS(sOConstruct an ARRAY. E.g.:: Column('myarray', ARRAY(Integer)) Arguments are: :param item_type: The data type of items of this array. Note that dimensionality is irrelevant here, so multi-dimensional arrays like ``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as ``ARRAY(ARRAY(Integer))`` or such. :param as_tuple=False: Specify whether return results should be converted to tuples from lists. DBAPIs such as psycopg2 return lists by default. When tuples are returned, the results are hashable. :param dimensions: if non-None, the ARRAY will assume a fixed number of dimensions. This will cause the DDL emitted for this ARRAY to include the exact number of bracket clauses ``[]``, and will also optimize the performance of the type overall. Note that PG arrays are always implicitly "non-dimensioned", meaning they can store any number of dimensions no matter how they were declared. :param zero_indexes=False: when True, index values will be converted between Python zero-based and Postgresql one-based indexes, e.g. a value of one will be added to all index values before passing to the database. .. versionadded:: 0.9.5 sUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN(RRt ValueErrorRRtas_tuplet dimensionsR(RRRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR}s$    cCstS(N(tlist(R((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt python_typescCs ||kS(N((Rtxty((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytcompare_valuesscsdkrt|}ndksTdkr| sTt|dttf rrtfd|DS|Sn#fd|DSdS(Niic3s|]}|VqdS(N((t.0R(titemproc(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys sc3s=|]3}j|dk r+dndVqdS(iN(t _proc_arrayR(RR(tdimRt collectionR(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys s(RRRttuple(RtarrRRR((RRRRsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs ! cs1jj|j|fd}|S(Ncs-|dkr|Sj|jtSdS(N(RRRR(R(t item_procR(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs (Rt dialect_implR(RRR((RRsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs     cs4jj|j||fd}|S(Ncs<|dkr|Sj|jjr1tntSdS(N(RRRRRR(R(RR(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs (RRR(RRRR((RRsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs     N(R}R~RRRRRtcomparator_factoryRRRRRRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRsIk -   tENUMcBsYeZdZdZdedZdedZdZdZ dZ dZ RS( s"Postgresql ENUM type. This is a subclass of :class:`.types.Enum` which includes support for PG's ``CREATE TYPE``. :class:`~.postgresql.ENUM` is used automatically when using the :class:`.types.Enum` type on PG assuming the ``native_enum`` is left as ``True``. However, the :class:`~.postgresql.ENUM` class can also be instantiated directly in order to access some additional Postgresql-specific options, namely finer control over whether or not ``CREATE TYPE`` should be emitted. Note that both :class:`.types.Enum` as well as :class:`~.postgresql.ENUM` feature create/drop methods; the base :class:`.types.Enum` type ultimately delegates to the :meth:`~.postgresql.ENUM.create` and :meth:`~.postgresql.ENUM.drop` methods present here. cOs2|jdt|_tt|j||dS(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. .. versionadded:: 0.7.4 t create_typeN(tpopRRRRR(RtenumsR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRscCsS|jjsdS| s9|jj||jd|j rO|jt|ndS(sEmit ``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(Rtsupports_native_enumthas_typetnameRtexecutetCreateEnumType(Rtbindt checkfirst((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR'!s   cCsR|jjsdS| s8|jj||jd|jrN|jt|ndS(sEmit ``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(RRRRRRt DropEnumType(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdrop9s  !cCs|js tSd|kry|d}d|jkrB|jd}nt}|jd<|j|k}|j|j|StSdS(sLook 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(RRtmemotsetRtaddR(RRRt ddl_runnertpg_enumstpresent((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_check_for_name_in_memosOs   cKs/|j||s+|jd|d|ndS(NRR(RR'(RttargetRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_table_createfscKs/|j||s+|jd|d|ndS(NRR(RR'(RRRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_metadata_createjscKs/|j||s+|jd|d|ndS(NRR(RR(RRRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_on_metadata_dropnsN( R}R~RRRRR'RRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs    tintegertbiginttsmallintscharacter varyingt characters"char"Rttexttnumerictfloattrealtinettcidrtuuidtbits bit varyingtmacaddrtoidsdouble precisiont timestampstimestamp with time zonestimestamp without time zonestime with time zonestime without time zonetdatettimetbyteatbooleanRsinterval year to monthsinterval day to secondttsvectort PGCompilercBseZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZRS(cKsd|j||S(Ns ARRAY[%s](tvisit_clauselist(RtelementR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_arrayscKs,d|j|j||j|j|fS(Ns%s:%s(RRR(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_slicescKs9d|j|j|tj|j|j|j|fS(Ns %s%sANY (%s)(RRrRt OPERATORSRRy(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_anys cKs9d|j|j|tj|j|j|j|fS(Ns %s%sALL (%s)(RRrRRRRy(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_alls cKs,d|j|j||j|j|fS(Ns%s[%s](RRrRy(RRhRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_getitem_binaryscKsd|jkrc|j|jdtj}|rcd|j|j|||j|j|fSnd|j|j||j|j|fS(Ntpostgresql_regconfigs%s @@ to_tsquery(%s, %s)s%s @@ to_tsquery(%s)(t modifierstrender_literal_valueRt STRINGTYPERRrRy(RRhRRt regconfig((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_match_op_binarys  cKsd|jjdd}d|j|j||j|j|f|r_d|j|tjndS(Ntescapes %s ILIKE %ss ESCAPE t( R$tgetRRRrRyR%RR&(RRhRRR)((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_ilike_op_binarys cKsd|jjdd}d|j|j||j|j|f|r_d|j|tjndS(NR)s%s NOT ILIKE %ss ESCAPE R*( R$R+RRRrRyR%RR&(RRhRRR)((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_notilike_op_binarys cCs@tt|j||}|jjr<|jdd}n|S(Ns\s\\(RRR%Rt_backslash_escapestreplace(RRttype_((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR%s cCsd|jj|S(Ns nextval('%s')(tpreparertformat_sequence(Rtseq((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_sequencescCsd}|jdk r;|d|jtj|j7}n|jdk r|jdkrf|d7}n|d|jtj|j7}n|S(NR*s LIMIT s LIMIT ALLs OFFSET (t_limitRRRtliteralt_offset(RRTR ((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt limit_clauses& &cCs0|jdkr(tjd|nd|S(NtONLYsUnrecognized hint: %rsONLY (tupperRt CompileError(RtsqltextRXthinttiscrud((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytformat_from_hint_textscCs|jtk r|jtkr"dSt|jttfrnddjg|jD]}|j|^qMdSd|j|jdSndSdS(Ns DISTINCT s DISTINCT ON (s, s) R*(t _distinctRRRRRRqR(RRTtcol((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_select_precolumnss4cs|jjrd}nd}|jjrptjd|jjD}|ddjfd|D7}n|jjr|d7}n|S(Ns FOR SHAREs FOR UPDATEcss0|]&}t|tjr$|jn|VqdS(N(RRt ColumnClauseRX(Rtc((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys ss OF s, c3s$|]}j|dtVqdS(tashintN(RR(RRX(R(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys ss NOWAIT(t_for_update_argtreadRHRt OrderedSetRqtnowait(RRTttmpttables((Rsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytfor_update_clauses       cCsHgtj|D]!}|jd|tti^q}ddj|S(Ns RETURNING s, (Rt_select_iterablest_label_select_columnRRRRq(Rtstmttreturning_colsRDtcolumns((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytreturning_clauses4cKs|j|jjd|}|j|jjd|}t|jjdkr}|j|jjd|}d|||fSd||fSdS(NiiisSUBSTRING(%s FROM %s FOR %s)sSUBSTRING(%s FROM %s)(RRtlen(RtfuncRtsRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_substring_func%s (R}R~RRR R!R"R(R,R-R%R4R8R?RBRLRRRV(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs            t PGDDLCompilercBs5eZdZdZdZdZdZRS(c KsB|jj|}|jj|j}|jr||jjkr|jjsat |t j  r|j dkst |j tjr|j jrt |t jr|d7}q(t |t j r|d7}q(|d7}nL|d|jjj|j7}|j|}|dk r(|d|7}n|js>|d7}n|S(Ns BIGSERIALs SMALLSERIALs SERIALt s DEFAULT s NOT NULL(R1t format_columnRRRt primary_keyRXt_autoincrement_columntsupports_smallserialRRt SmallIntegerRRRtSequencetoptionalt BigIntegert type_compilerRtget_column_default_stringtnullable(RR%Rtcolspect impl_typeR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_column_specification1s*          cs?|j}djj|djfd|jDfS(NsCREATE TYPE %s AS ENUM (%s)s, c3s0|]&}jjtj|dtVqdS(t literal_bindsN(t sql_compilerRRR6R(Rte(R(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys Vs(RR1t format_typeRqR(RR'R0((Rsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_create_enum_typePs   cCs|j}d|jj|S(Ns DROP TYPE %s(RR1Rj(RRR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_drop_enum_typeZs c Cs|j}|j}|j|d}|jr;|d7}n|d|j|dt|j|jf7}|jdd}|r|d|j |7}n|jdd}|d d j gt |j |j D]l\}}|jjt|tjs|jn|d td t|j|kr3d ||jp6d^q7}|jdd} | dk r|jj| d td t} |d| 7}n|S(NsCREATE sUNIQUE sINDEX %s ON %s tinclude_schemat postgresqlR`s USING %s topss(%s)s, t include_tableRgRXR*Rcs WHERE (R1Rt_verify_index_tableR^t_prepared_index_nameRt format_tableRXtdialect_optionstquoteRqtzipt expressionsRQRhRRRRCRRtkeyR( RR'R1RR R`RoRRDt whereclausetwhere_compiled((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_create_indexas2          cCsd}|jdk r2|d|jj|7}ng}xE|jD]:}|j|j}|j|jj|jd|qBW|d|jdj |f7}|j dk r|d|j j |j dt 7}n||j|7}|S(NR*sCONSTRAINT %s s WITH sEXCLUDE USING %s (%s)s, s WHERE (%s)Rg(RRR1tformat_constraintRQR tappendRuR`RqRcRhRRtdefine_constraint_deferrability(RR&R telementsRDR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_exclude_constraints (  (R}R~RfRkRlR{R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRW/s    'tPGTypeCompilercBseZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZRS(cCsdS(NR((RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_TSVECTORscCsdS(NR((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_INETscCsdS(NR((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_CIDRscCsdS(NR((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_MACADDRscCsdS(NR((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_OIDscCs#|js dSdi|jd6SdS(NRsFLOAT(%(precision)s)R(R(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_FLOATs cCsdS(NsDOUBLE PRECISION((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_DOUBLE_PRECISIONscCsdS(NR ((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_BIGINTscCsdS(NtHSTORE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_HSTOREscCsdS(NtJSON((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_JSONscCsdS(NtJSONB((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_JSONBscCsdS(Nt INT4RANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INT4RANGEscCsdS(Nt INT8RANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INT8RANGEscCsdS(NtNUMRANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_NUMRANGEscCsdS(Nt DATERANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_DATERANGEscCsdS(NtTSRANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_TSRANGEscCsdS(Nt TSTZRANGE((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_TSTZRANGEscCs |j|S(N(tvisit_TIMESTAMP(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_datetimescCs>|j s|jj r-tt|j|S|j|SdS(N(t native_enumRRRRt visit_enumt visit_ENUM(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRscCs|jjj|S(N(Rtidentifier_preparerRj(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRscCs@dt|ddr"d|jp%d|jr4dp7ddfS(NsTIMESTAMP%s %sRs(%d)R*tWITHtWITHOUTs TIME ZONE(tgetattrRRR(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs cCs@dt|ddr"d|jp%d|jr4dp7ddfS(Ns TIME%s %sRs(%d)R*RRs TIME ZONE(RRRR(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_TIMEs cCs"|jdk rd|jSdSdS(Ns INTERVAL(%d)R(RR(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_INTERVALs cCsF|jr5d}|jdk rB|d|j7}qBn d|j}|S(Ns BIT VARYINGs(%d)sBIT(%d)(RRR(RR0tcompiled((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_BITs   cCsdS(NR ((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_UUIDscCs |j|S(N(t visit_BYTEA(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytvisit_large_binaryscCsdS(NR|((RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRscCs0|j|jd|jdk r*|jndS(Ns[]i(RRRR(RR0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt visit_ARRAYs(R}R~RRRRRRRRRRRRRRRRRRRRRRRRRRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs8                          tPGIdentifierPreparercBs#eZeZdZedZRS(cCs9|d|jkr5|dd!j|j|j}n|S(Niii(t initial_quoteR/tescape_to_quotet escape_quote(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_unquote_identifiers cCsm|jstjdn|j|j}|j ri|ri|jdk ri|j|jd|}n|S(Ns%Postgresql ENUM type requires a name.t.(RRR;Rut omit_schemaRRt quote_schema(RR0t use_schemaR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRjs  (R}R~tRESERVED_WORDStreserved_wordsRRRj(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR s t PGInspectorcBseZdZddZRS(cCstjj||dS(N(Rt InspectorR(Rtconn((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR!scCs"|jj|j||d|jS(s.Return the oid from `table_name` and `schema`.t info_cache(Rt get_table_oidRR(Rt table_nameR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR$sN(R}R~RRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs RcBseZdZRS(tcreate_enum_type(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR+sRcBseZdZRS(tdrop_enum_type(R}R~R(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR/stPGExecutionContextcBseZdZdZRS(cCs#|jd|jjj||S(Nsselect nextval('%s')(t_execute_scalarRRR2(RR3R0((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt fire_sequence5sc Css|jr]||jjkr]|jrM|jjrM|jd|jj|jS|jdkst|jj r]|jj r]y |j }Wnt k r|jj}|j}|ddtddt|!}|ddtddt|!}d||f}||_ }nX|jj}|dk r:d||f}n d|f}|j||jSntt|j|S(Ns select %siis %s_%s_seqsselect nextval('"%s"."%s"')sselect nextval('"%s"')(RZRXR[tserver_defaultt has_argumentRtargRRRt is_sequenceR_t_postgresql_seq_nametAttributeErrorRtmaxRSRRRtget_insert_default(RR%tseq_namettabRARtschR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR:s4          $$   (R}R~RR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR3s t PGDialectcBseZdZeZdZeZeZeZeZ eZ eZ eZ e ZeZe ZeZdZeZeZeZeZeZeZeZeZ d*Z"e#j$ie d6d*d6id6fe#j%ie d6fgZ&d+Z'eZ(d*d*d*dZ)d Z*d Z+e,d d d dgZ-dZ.dZ/dZ0dZ1ee dZ2ee dZ3dZ4dZ5dZ6d*dZ7d*dZ8d*dZ9dZ:e;j<d*dZ=e;j<dZ>e;j<d*dZ?e;j<d*dZ@e;j<d*d ZAe;j<d*d!ZBd"ZCe;j<d*d#ZDe;j<d*e d$ZEd%ZFe;j<d&ZGe;j<d*d'ZHd(ZId)ZJRS(,Rni?tpyformatR`RcRotignore_search_pathtpostgresql_ignore_search_pathcKs2tjj||||_||_||_dS(N(RtDefaultDialectRtisolation_levelt_json_deserializert_json_serializer(RRtjson_serializertjson_deserializerR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs  cCstt|j||jdko7|jjdt|_|jd k|_|js|j j |_ |j j t j d|j j tdn|jd k|_|jd kp|jddk|_dS( Niitimplicit_returningii s show standard_conforming_stringsRI(ii(ii(i i(ii(RRt initializetserver_version_infot__dict__R+RRRtcolspecstcopyRRtEnumRRR\tscalarR.(Rt connection((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs cs*jdk r"fd}|SdSdS(Ncsj|jdS(N(tset_isolation_levelR(R(R(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytconnects(RR(RR((Rsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt on_connectst SERIALIZABLEsREAD UNCOMMITTEDsREAD COMMITTEDsREPEATABLE READcCs|jdd}||jkrOtjd||jdj|jfn|j}|jd||jd|jdS(Nt_RXsLInvalid value '%s' for isolation_level. Valid isolation levels for %s are %ss, s=SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL %stCOMMIT( R/t_isolation_lookupRt ArgumentErrorRRqtcursorRtclose(RRtlevelR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRs%  cCs=|j}|jd|jd}|j|jS(Ns show transaction isolation leveli(RRtfetchoneRR:(RRRtval((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_isolation_levels    cCs|j|jdS(N(tdo_beginR(RRtxid((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_begin_twophasescCs|jd|dS(NsPREPARE TRANSACTION '%s'(R(RRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_prepare_twophasescCsa|rM|r|jdn|jd||jd|j|jn|j|jdS(NtROLLBACKsROLLBACK PREPARED '%s'tBEGIN(Rt do_rollbackR(RRRt is_preparedtrecover((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_rollback_twophases cCsa|rM|r|jdn|jd||jd|j|jn|j|jdS(NRsCOMMIT PREPARED '%s'R(RRRt do_commit(RRRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_commit_twophases cCs3|jtjd}g|D]}|d^qS(Ns!SELECT gid FROM pg_prepared_xactsi(RRR (RRt resultsettrow((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytdo_recover_twophasescCs |jdS(Nsselect current_schema()(R(RR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_get_default_schema_namesc Cs[d}|jtj|dtjdtj|jdtjg}t |j S(Ns=select nspname from pg_namespace where lower(nspname)=:schemat bindparamsRR0( RRR t bindparamRRtlowerRtUnicodetbooltfirst(RRRtqueryR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt has_schemasc Cs|dkrN|jtjddtjdtj|dtjg}n`|jtjddtjdtj|dtjtjdtj|dtjg}t |j S(Ns}select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where n.nspname=current_schema() and relname=:nameRRR0stselect relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where n.nspname=:schema and relname=:nameR( RRRR RRRRRRR(RRRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt has_tables     c Cs|dkrN|jtjddtjdtj|dtjg}n`|jtjddtjdtj|dtjtjdtj|dtjg}t |j S(NsSELECT relname FROM pg_class c join pg_namespace n on n.oid=c.relnamespace where relkind='S' and n.nspname=current_schema() and relname=:nameRRR0sSELECT relname FROM pg_class c join pg_namespace n on n.oid=c.relnamespace where relkind='S' and n.nspname=:schema and relname=:nameR( RRRR RRRRRRR(RRt sequence_nameRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt has_sequence!s   cCs|dk r$d}tj|}nd}tj|}|jtjdtj|dtj}|dk r|jtjdtj|dtj}n|j |}t |j S(Ns  SELECT EXISTS ( SELECT * FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n WHERE t.typnamespace = n.oid AND t.typname = :typname AND n.nspname = :nspname ) s SELECT EXISTS ( SELECT * FROM pg_catalog.pg_type t WHERE t.typname = :typname AND pg_type_is_visible(t.oid) ) ttypnameR0tnspname( RRR RRRRRRRRR(RRt type_nameRRR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRAs    !cCs~|jdj}tjd|}|s@td|ntg|jdddD]}|dk rYt|^qYS(Nsselect version()sJ.*(?:PostgreSQL|EnterpriseDB) (\d+)\.(\d+)(?:\.(\d+))?(?:\.\d+)?(?:devel)?s,Could not determine version from string '%s'iii( RRtretmatchtAssertionErrorRR;Rtint(RRtvtmR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt_get_server_version_infoas c Ksd}|dk rd}nd}d|}tj|}|dk rXtj|}ntj|jdtj}|jdtj }|r|jtj ddtj}n|j |d|d|} | j }|dkrt j|n|S( sFetch the oid for schema.table_name. Several reflection methods require the table oid. The idea for using this method is that it can be fetched one time and cached for subsequent calls. sn.nspname = :schemas%pg_catalog.pg_table_is_visible(c.oid)s SELECT c.oid FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE (%s) AND c.relname = :table_name AND c.relkind in ('r','v') RRRR0N(RRRRR RRRRQtIntegerRRRRtNoSuchTableError( RRRRRt table_oidtschema_where_clauseRRURD((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRls"     $  cKsd}|j|}tjr]g|D]/}|djds%|dj|j^q%}n0g|D]#}|djdsd|d^qd}|S(NsS SELECT nspname FROM pg_namespace ORDER BY nspname itpg_(RRtpy2kt startswithtdecodetencoding(RRRRUtrpRt schema_names((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_schema_namess  2 #cKse|dk r|}n |j}|jtjd|ditjd6}g|D]}|d^qQS(NsSELECT relname FROM pg_class c WHERE relkind = 'r' AND '%s' = (select nspname from pg_namespace n where n.oid = c.relnamespace) ttypemaptrelnamei(Rtdefault_schema_nameRRR RR(RRRRRjtresultR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_table_namess    cKs|dk r|}n |j}dtd|}tjrog|j|D]}|dj|j^qJ}n&g|j|D]}|d^q}|S(Ns SELECT relname FROM pg_class c WHERE relkind = 'v' AND '%(schema)s' = (select nspname from pg_namespace n where n.oid = c.relnamespace) Ri(RR"tdictRRRRR(RRRRRjRURt view_names((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_view_namess    2&c Ks|dk r|}n |j}d}|jtj|d|d|}|rtjrr|jj|j }n |j}|SdS(Nsv SELECT definition FROM pg_views WHERE schemaname = :schema AND viewname = :view_name t view_nameR( RR"RRR RRRRR( RRR(RRRjRURtview_def((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_view_definitions     c Ks|j|||d|jd}d}tj|dtjddtjgditjd6tjd6}|j|d|}|j } |j |} |j |} g} xN| D]F\} }}}}}|j | |||| | |}| j |qW| S( NRs6 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 FROM pg_catalog.pg_attribute a WHERE a.attrelid = :table_oid AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum RRR0R tattnameR(RR+RR RRRRRtfetchallt _load_domainst _load_enumst_get_column_infoR}(RRRRRRtSQL_COLSRURDtrowstdomainsRRQRRjRRutattnumt column_info((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_columnss$   c Cstjdd|}tjdd|}| } |jd} tjd|} | rj| jd} ntjd|} | r| jdrttjd| jd} nd(} i} |d kr | r| jd \}}t|t|f} q#d)} n|d kr!d*} n|d kr6d+} n|d,krnt| d<| ret| | dc Ks|j|||d|jd}|jdkrLd|jdd}nd}tj|ditjd 6}|j|d |}g|j D]} | d ^q} d } tj| ditjd 6}|j|d |}|j } i| d6| d6S(NRiisq SELECT a.attname FROM pg_class t join pg_index ix on t.oid = ix.indrelid join pg_attribute a on t.oid=a.attrelid AND %s WHERE t.oid = :table_oid and ix.indisprimary = 't' ORDER BY a.attnum sa.attnums ix.indkeys SELECT a.attname FROM pg_attribute a JOIN ( SELECT unnest(ix.indkey) attnum, generate_subscripts(ix.indkey, 1) ord FROM pg_index ix WHERE ix.indrelid = :table_oid AND ix.indisprimary ) k ON a.attnum=k.attnum WHERE a.attrelid = :table_oid ORDER BY k.ord R R+Ris SELECT conname FROM pg_catalog.pg_constraint r WHERE r.conrelid = :table_oid AND r.contype = 'p' ORDER BY 1 tconnametconstrained_columnsR(ii( RR+Rt _pg_index_anyRR RRRR,R( RRRRRRtPK_SQLttRDtrtcolst PK_CONS_SQLR((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_pk_constraintts # cKsA|j}|j|||d|jd}d}tjd} tj|ditjd6tjd6} |j | d|} g} x| j D]\} }}tj | |j }|\ }}}}}}}}}}}}}|dk r|dkrtnt}ngtjd |D]}|j|^q!}|rc||jkrZ|}q|}n9|r{|j|}n!|dk r||kr|}n|j|}gtjd |D]}|j|^q}i| d 6|d 6|d 6|d6|d6i|d6|d6|d6|d6|d6d6}| j|qW| S(NRs 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 RGtcondefRXt DEFERRABLEs\s*,\s*s\s*,\sRRHtreferred_schematreferred_tabletreferred_columnstonupdatetondeleteR.R>Rtoptions(RRR+R tcompileRR RRRR,R<tgroupsRRRR=RR"R}(RRRRRRR1RtFK_SQLtFK_REGEXRKRDtfkeysRGRPt conschemaRRHRRRSRTRRRURVR.R>Rtfkey_d((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pytget_foreign_keyssX   - %   +csN|jd kr<ddjfdtddDSdfSdS( Niis(%s)s OR c3s"|]}d|fVqdS(s %s[%d] = %sN((Rtind(RAt compare_to(si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pys  sii s %s = ANY(%s)(ii(RRqtrange(RRARa((RaRAsi/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRIs  cKs|j|||d|jd}d|jdkr<dnd|jddf}tj|d itjd 6}|j|d |}t d } d} x|j D]} | \} } }}}}}|r| | krt j d | n| } qn|r+| | k r+t j d| | } n| | }|dk rR||d|4 ss;Skipped unsupported reflection of expression-based index %ss7Predicate of partial index %s ignored during reflectionRMRxR^Rt column_names(ii(RR+RRIRR RRRRRR,RR?R=Rtstriptitems(RRRRRRtIDX_SQLRKRDtindexest sv_idx_nameRtidx_nameR^RtprdRAtcol_numtidx_keyRtkRtidxti((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyt get_indexes s<     /cKs|j|||d|jd}d}tj|ditjd6}|j|d|}td} xB|jD]4} | | j } | j | d<| j | d| j  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' ORDER BY "name", e.oid -- e.oid gives us label order R R+tlabeltvisibleRs%s.%sRR7(RRR RRRR,R}(RRt SQL_ENUMSRURDRRER((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyR.{ s"     c Csd}tj|ditjd6}|j|}i}x|jD]{}tjd|djd}|dr|d}nd |d |df}i|d6|d d 6|d d 6||RRtstatement_compilerRWt ddl_compilerRRaRR1Rtexecution_ctx_clsRt inspectorRRRtIndextTabletconstruct_argumentstreflection_optionsR.RRRRRRRRRRRRRRRR RRRtcacheRRR$R'R*R5R/ROR_RIRqRvR.R-(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyRcs                #& p/Y H# ,([Rt collectionsRR R*RRRRtengineRRRRR R RRR Rt ImportErrorRtsqlalchemy.typesR R RRRRRRRRRRRt_DECIMAL_TYPESt _FLOAT_TYPESt _INT_TYPESt LargeBinaryR|tFloatRt TypeEngineRtPGInetRtPGCidrRt PGMacAddrRRRRt PGIntervalRtPGBittPGUuidRt ColumnElementRRRtTupleRRRtPGArrayRRRRtStringR>t SQLCompilerRt DDLCompilerRWtGenericTypeCompilerRtIdentifierPreparerRRRt_CreateDropBaseRRtDefaultExecutionContextRRR(((si/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/postgresql/base.pyts "  L     2 3$     lp 0