�
��4]c@s�dZd
dl
mZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
dd	lm	Z

dd
lmZ
ddlm
Z

ddlmZ
ejd
��
Zdef
d��YZdS(s�Provides an abstraction for obtaining database schema information.

Usage Notes:

Here are some general conventions when accessing the low level inspector
methods such as get_table_names, get_columns, etc.

1. Inspector methods return lists of dicts in most cases for the following
   reasons:

   * They're both standard types that can be serialized.
   * Using a dict instead of a tuple allows easy expansion of attributes.
   * Using a list for the outer structure maintains order and is easy to work
     with (e.g. list comprehension [d['name'] for d in cols]).

2. Records that contain a name, such as the column name in a column record
   use the key 'name'. So for most return values, each record will have a
   'name' attribute..
i
(
tConnectablei(
texc(
t
inspection(
tsql(
tutil(
t	operators(
tschema(
t
TypeEngine(
t
deprecated(
ttopologicalcOs�|jd
d�}|dkr1||
|||�S|jtd�|D�
�
td�|j�D�
�
f}|j|�
}|dkr�||
|||�}|||<n|S(Nt
info_cachec
ss'|]}
t|
t
j�r|
V
qdS(
N(t
isinstanceRtstring_types(t.0t
a((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys	<genexpr>/sc
ssA|]7\}
}t|t
jt
jtf
�r|
|fV
qdS(
N(RRRt	int_typestfloat(R
t
kt
v((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys	<genexpr>1s
	
(tgettNonet__name__ttupletitems(tfntselftcontargstkwR
tkeytret((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pytcache(s










t	InspectorcBs�
eZ
dZd
�Zed��
Zeje�
d��
Z	e
d��
Zd�Ze
jdd'�
d(d(d	��
Zd(d
�
Zd�Zd�Zd(d
�
Zd(d�
Zd(d�
Zd(d�
Zedd�d(d�
�
Zd(d�
Zd(d�
Zd(d�
Zd(d�
Zd(d�
Zd(d�
Zd)e d(d�Z!d�Z"d�Z#d�Z$d�Z%de&j'fd e&j(fd!e&j)fd"e&j*fgZ+d#�Z,d$�Z-d%�Z.d&�Z/RS(*smPerforms database schema inspection.

    The Inspector acts as a proxy to the reflection methods of the
    :class:`~sqlalchemy.engine.interfaces.Dialect`, providing a
    consistent interface as well as caching support for previously
    fetched metadata.

    A :class:`.Inspector` object is usually created via the
    :func:`.inspect` function::

        from sqlalchemy import inspect, create_engine
        engine = create_engine('...')
        insp = inspect(engine)

    The inspection method above is equivalent to using the
    :meth:`.Inspector.from_engine` method, i.e.::

        engine = create_engine('...')
        insp = Inspector.from_engine(engine)

    Where above, the :class:`~sqlalchemy.engine.interfaces.Dialect` may opt
    to return an :class:`.Inspector` subclass that provides additional
    methods specific to the dialect's target database.

    cCsn|
|_t
|
d
�r'|
j|_n	|
|_|j|
krR|
j�j�
n|jj|_i|_dS(sj
Initialize a new :class:`.Inspector`.

        :param bind: a :class:`~sqlalchemy.engine.Connectable`,
          which is typically an instance of
          :class:`~sqlalchemy.engine.Engine` or
          :class:`~sqlalchemy.engine.Connection`.

        For a dialect-specific instance of :class:`.Inspector`, see
        :meth:`.Inspector.from_engine`

        tengineN(tbindthasattrR!tconnecttclosetdialectR
(RR"((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt__init__Xs
	
	
cCs,t|
j
d
�r"|
j
j|
�
St|
�
S(s�Construct a new dialect-specific Inspector object from the given
        engine or connection.

        :param bind: a :class:`~sqlalchemy.engine.Connectable`,
          which is typically an instance of
          :class:`~sqlalchemy.engine.Engine` or
          :class:`~sqlalchemy.engine.Connection`.

        This method differs from direct a direct constructor call of
        :class:`.Inspector` in that the
        :class:`~sqlalchemy.engine.interfaces.Dialect` is given a chance to
        provide a dialect-specific :class:`.Inspector` instance, which may
        provide additional methods.

        See the example at :class:`.Inspector`.

        t	inspector(R#R&R(R (tclsR"((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pytfrom_enginets

c

Cs
tj
|�
S(
N(R R*(
R"((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt_insp�sc


Cs
|jj
S(
s�Return the default schema name presented by the dialect
        for the current engine's database user.

        E.g. this is typically ``public`` for PostgreSQL and ``dbo``
        for SQL Server.

        (R&tdefault_schema_name(
R((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR,�s	c

Cs2t|j
d
�r.|j
j|jd|j�

SgS(s!Return all schema names.
        tget_schema_namesR
(R#R&R-R"R
(
R((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR-�s
	
torder_bys1.0s�The :paramref:`get_table_names.order_by` parameter is deprecated and will be removed in a future release.  Please refer to :meth:`.Inspector.get_sorted_table_and_fkc_names` for a more comprehensive solution to resolving foreign key cycles between tables.cCs�t|j
d
�r6|j
j|j|
d|j�
}n|jj|
�
}|dkr�g}xU|D]M}xD|j||
�D]0}||dkrz|j|d|f�

qzqzWqaWt	t
j||��
}n|S(s�Return all table names in referred to within a particular schema.

        The names are expected to be real tables only, not views.
        Views are instead returned using the :meth:`.Inspector.get_view_names`
        method.


        :param schema: Schema name. If ``schema`` is left at ``None``, the
         database's default schema is
         used, else the named schema is searched.  If the database does not
         support named schemas, behavior is undefined if ``schema`` is not
         passed as ``None``.  For special quoting, use :class:`.quoted_name`.

        :param order_by: Optional, may be the string "foreign_key" to sort
         the result on foreign key dependencies.  Does not automatically
         resolve cycles, and will raise :class:`.CircularDependencyError`
         if cycles exist.

        .. seealso::

            :meth:`.Inspector.get_sorted_table_and_fkc_names`

            :attr:`.MetaData.sorted_tables`

        tget_table_namesR
tforeign_keytreferred_table(R#R&R/R"R
R!ttable_namestget_foreign_keystappendtlistR	tsort(RRR.ttnamesttuplesttnametfkey((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR/�s%
	







"

cs�
t|j
d
�r6|j
j|j|
d|j�
}n|jj|
�
}t�}t�}i}x�|D]z}|j||
�}tg|D]}|d^q��
||<x8|D]0}	||	dkr�|j	|	d|f�

q�q�WqgWyt
tj||��
}
Wntt
jk
rw

}
xC|jD]8�|j��

|j�f
d�|�dD�
�

q 
Wt
tj||��
}
n
Xg|
D]}|||j|�
f^q
dt
|�
fg
S(sxReturn dependency-sorted table and foreign key constraint names in
        referred to within a particular schema.

        This will yield 2-tuples of
        ``(tablename, [(tname, fkname), (tname, fkname), ...])``
        consisting of table names in CREATE order grouped with the foreign key
        constraint names that are not detected as belonging to a cycle.
        The final element
        will be ``(None, [(tname, fkname), (tname, fkname), ..])``
        which will consist of remaining
        foreign key constraint names that would require a separate CREATE
        step after-the-fact, based on dependencies between tables.

        .. versionadded:: 1.0.-

        .. seealso::

            :meth:`.Inspector.get_table_names`

            :func:`.sort_tables_and_constraints` - similar method which works
             with an already-given :class:`.MetaData`.

        R/R
tnameR1c
3s|]}
�d|
fV
qd
S(i
N((R
tfkc(
tedge(sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys	<genexpr>
si
N(R#R&R/R"R
R!R2tsetR3taddR5R	R6R
tCircularDependencyErrortedgestremovetupdatet
differenceR(RRR7R8tremaining_fkcstfknames_for_tableR9tfkeystfkR:tcandidate_sortterr((
R=sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pytget_sorted_table_and_fkc_names�s0
	
	
	



'



"







#
&
c

Cs|jj
|jd
|j�

S(s�return a list of temporary table names for the current bind.

        This method is unsupported by most dialects; currently
        only SQLite implements it.

        .. versionadded:: 1.0.0

        R
(R&tget_temp_table_namesR"R
(
R((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRL
s		
c

Cs|jj
|jd
|j�

S(s�return a list of temporary view names for the current bind.

        This method is unsupported by most dialects; currently
        only SQLite implements it.

        .. versionadded:: 1.0.0

        R
(R&tget_temp_view_namesR"R
(
R((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRM
s		
cKs;t|j
d
�r7|j
j|j|
|d|j|�
SiS(s�
Return a dictionary of options specified when the table of the
        given name was created.

        This currently includes some options that apply to MySQL tables.

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        tget_table_optionsR
(R#R&RNR"R
(Rt
table_nameRR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRN*
s
	
cCs|jj
|j|
d
|j�
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`.

        R
(R&tget_view_namesR"R
(RR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRP>
s	
cCs"|jj
|j|
|d
|j�
S(s�Return definition for `view_name`.

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

        R
(R&tget_view_definitionR"R
(Rt	view_nameR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRQJ
s	
cKse|jj
|j|
|d
|j|�
}x7|D]/}|d}t|t�s.|�|d<q.q.W|S(s�Return information about columns in `table_name`.

        Given a string `table_name` and an optional string `schema`, return
        column information as a list of dicts with these keys:

        * ``name`` - the column's name

        * ``type`` - the type of this column; an instance of
          :class:`~sqlalchemy.types.TypeEngine`

        * ``nullable`` - boolean flag if the column is NULL or NOT NULL

        * ``default`` - the column's server default value - this is returned
          as a string SQL expression.

        * ``attrs``  - dict containing optional column attributes

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        :return: list of dictionaries, each representing the definition of
         a database column.

        R
ttype(R&tget_columnsR"R
RR(RRORRtcol_defstcol_deftcoltype((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRTV
s	





s0.7s�The :meth:`.Inspector.get_primary_keys` method is deprecated and will be removed in a future release.  Please refer to the :meth:`.Inspector.get_pk_constraint` method.cKs)|jj
|j|
|d
|j|�
dS(s�Return information about primary keys in `table_name`.

        Given a string `table_name`, and an optional string `schema`, return
        primary key information as a list of column names.
        R
tconstrained_columns(R&tget_pk_constraintR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pytget_primary_keys~
s
	

cKs%|jj
|j|
|d
|j|�
S(s�Return information about primary key constraint on `table_name`.

        Given a string `table_name`, and an optional string `schema`, return
        primary key information as a dictionary with these keys:

        constrained_columns
          a list of column names that make up the primary key

        name
          optional name of the primary key constraint.

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        R
(R&RYR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRY�
s	
cKs%|jj
|j|
|d
|j|�
S(s�Return information about foreign_keys in `table_name`.

        Given a string `table_name`, and an optional string `schema`, return
        foreign key information as a list of dicts with these keys:

        constrained_columns
          a list of column names that make up the foreign key

        referred_schema
          the name of the referred schema

        referred_table
          the name of the referred table

        referred_columns
          a list of column names in the referred table that correspond to
          constrained_columns

        name
          optional name of the foreign key constraint.

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        R
(R&R3R"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR3�
s	
cKs%|jj
|j|
|d
|j|�
S(s�Return information about indexes in `table_name`.

        Given a string `table_name` and an optional string `schema`, return
        index information as a list of dicts with these keys:

        name
          the index's name

        column_names
          list of column names in order

        unique
          boolean

        column_sorting
          optional dict mapping column names to tuple of sort keywords,
          which may include ``asc``, ``desc``, ``nullsfirst``, ``nullslast``.

          .. versionadded:: 1.3.5

        dialect_options
          dict of dialect-specific index options.  May not be present
          for all dialects.

          .. versionadded:: 1.0.0

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        R
(R&tget_indexesR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR[�
s$	
cKs%|jj
|j|
|d
|j|�
S(soReturn information about unique constraints in `table_name`.

        Given a string `table_name` and an optional string `schema`, return
        unique constraint information as a list of dicts with these keys:

        name
          the unique constraint's name

        column_names
          list of column names in order

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        R
(R&tget_unique_constraintsR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR\�
s	
cKs%|jj
|j|
|d
|j|�
S(s�
Return information about the table comment for ``table_name``.

        Given a string ``table_name`` and an optional string ``schema``,
        return table comment information as a dictionary with these keys:

        text
            text of the comment.

        Raises ``NotImplementedError`` for a dialect that does not support
        comments.

        .. versionadded:: 1.2

        R
(R&tget_table_commentR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR]s	
cKs%|jj
|j|
|d
|j|�
S(s�Return information about check constraints in `table_name`.

        Given a string `table_name` and an optional string `schema`, return
        check constraint information as a list of dicts with these keys:

        name
          the check constraint's name

        sqltext
          the check constraint's SQL expression

        :param table_name: string name of the table.  For special quoting,
         use :class:`.quoted_name`.

        :param schema: string schema name; if omitted, uses the default schema
         of the database connection.  For special quoting,
         use :class:`.quoted_name`.

        .. versionadded:: 1.1.0

        R
(R&tget_check_constraintsR"R
(RRORR((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR^s	
c	s|d
k	r,�|krd
S|j
��

n|jj}|jj��
}�j}t�f
d�|jD�
�
}	|j||�j	�}
|
r��j
|
�

ntjr�t
|t�r�|j|j�
}nt
|t�r�|j|j�
}q�nt}i}x?|j||�j	�D]%}
t}|j�|
|||�
q
W|s]
tj�j�
�
n|j||�||�
|j||�|||||	�
|j||�||||	�
|j||�||||	�
|j||�||||	�
|j||�|	�
d
S(sGiven a Table object, load its internal constructs based on
        introspection.

        This is the underlying method used by most dialects to produce
        table reflection.  Direct usage is like::

            from sqlalchemy import create_engine, MetaData, Table
            from sqlalchemy.engine.reflection import Inspector

            engine = create_engine('...')
            meta = MetaData()
            user_table = Table('user', meta)
            insp = Inspector.from_engine(engine)
            insp.reflecttable(user_table, None)

        :param table: a :class:`~sqlalchemy.schema.Table` instance.
        :param include_columns: a list of string column names to include
          in the reflection process.  If ``None``, all columns are reflected.

        Nc
3s6|],}
|
�jkr|
�jj
|
�
fV
qdS(
N(tdialect_kwargsR(R
R(
ttable(sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys	<genexpr>hs

(RR?R"R&tschema_for_objectR;tdicttreflection_optionsRNR_t_validate_dialect_kwargsRtpy2kRtstrtdecodetencodingtFalseRTtTruet_reflect_columnR
tNoSuchTableErrort_reflect_pkt_reflect_fkt_reflect_indexest_reflect_unique_constraintst_reflect_check_constraintst_reflect_table_comment(RR`tinclude_columnstexclude_columnstresolve_fkst
_extend_onR&RRORcttbl_optstfound_tabletcols_by_orig_nametcol_d((
R`sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pytreflecttable:s�

	


	




	





































c
s�
�d
}|
jj
||
��
�d
}|r<||ksN|rR||krRdS�d}t�f
d�dddddd	gD�
�
}	d
�kr�|	j�d
�

ng}
�jd�
dk	rC
�d}t|tjj	�r�t
j|dt�

}n7t|t
j
�s3
t
jtj�d�
dt�

}n|
j|�

nd
�krb
|j�|
�
nt
j|||
|	�||<}|j|
jkr�
t|_n|
j|�

dS(NR;RSc
3s+|]!}
|
�kr|
�|
fV
qdS(
N((R
R(
Rz(sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys	<genexpr>�s
tnullablet
autoincrementtquotetinfoRtcommenttdialect_optionstdefaultt
_reflectedtsequence(tdispatchtcolumn_reflectRbRCRRRRtelementst
TextClauset	sa_schemat
DefaultClauseRjtFetchedValuettextR4t_reflect_col_sequencetColumnRtprimary_keyt
append_column(
RR`RzRsRtRyt	orig_nameR;RWtcol_kwtcolargsR�tcol((
RzsO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRk�sB























cCs{d
|
krw|
d
}tj
|ddd�}d|krK|d|_nd|krg|d|_n|j|�

ndS(NR�R;i
tstartt	increment(R�tSequenceR�R�R4(RRzR�tseqR�((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR��s







c	Cs�|j|
||j
�}|rg|d
D](}||kr)||kr)||^q)}|jd�
|j_|jj|�

ndS(NRXR;(RYR_RR�R;t_reload(	RRORR`RyRttpk_constpktpk_cols((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRms


(c	
Cs�
|j|
||j
�}	x�
|	D]�
}
|
d
}g|
dD]%}||krY||jn|^q:}
|r�t|
�
j|�
r�qn|
d}|
d}|
d}g}|dk	r#
|r�tj||jdt	d|d|j
d	||�
nx�|D]%}|jd
j|||g�
�

q�Wnj|r`
tj||jdt	d|j
dtj
d	||�
nx*|D]"}|jd
j||g�
�

qg
Wd|
kr�
|
d}ni}|jtj|
||dt	|�
�

qWdS(
NR;RXtreferred_schemaR1treferred_columnstautoloadRt
autoload_withRvt
.toptionstlink_to_name(R3R_RR>tintersectionRR�tTabletmetadataRjR"R4tjointBLANK_SCHEMAtappend_constrainttForeignKeyConstraint(RRORR`RyRtRuRvRcRGtfkey_dtconnamet
cRXR�R1R�trefspectcolumnR�((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRns^




3
	











	


	





 


	

	
	




 









tasctdesct
nullsfirstt	nullslastc
Cs�
|j|
|�}x�
|D]�
}	|	d
}
|	d}|	j
di�}|	d}
|	j
dd�}|	j
di�}|	j
d�
}|r�t|�
j|�
r�tjd	|d
j|�
f�

qn|r�qng}x�|D]�}y'||kr�||n
|j|}Wn.tk
r:



tjd|||
f�

q�n
X|j
|d
�}x2|j	D]'\}}||krW
||�
}qW
qW
W|j
|�

q�Wtj|
d||t
t|j��
d|
fg
�
�


qWdS(NR;tcolumn_namestcolumn_sortingtuniqueRStindexR�tduplicates_constraints5Omitting %s key for (%s), key covers omitted columns.s, s5%s key '%s' was not located in columns for table '%s't_table((R[RR>tissubsetRtwarnR�R�tKeyErrort_index_sort_exprsR4R�tIndexRbR5R(RRORR`RyRsRtRctindexestindex_dR;tcolumnsR�R�tflavorR�t
duplicatestidx_colsR�tidx_colt	c_sortingRtop((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRogsF































cCs=
y|j|
|�}Wnt
k
r*


dSXx
|D]
}	|	d
}
|	d}|	jd�
}|r�t|�
j|�
r�tjddj|�
�

q2n|r�q2ng}
xm|D]e}y'||kr�||n
|j|}Wn(t	k
r



tjd||
f�

q�X|
j
|�

q�W|jtj
d
|
|
�
�

q2WdS(NR;R�tduplicates_indexsDOmitting unique constraint key for (%s), key covers omitted columns.s, sDunique constraint key '%s' was not located in columns for table '%s'(R\tNotImplementedErrorRR>R�RR�R�R�R�R4R�R�tUniqueConstraint(RRORR`RyRsRtRctconstraintstconst_dR�R�R�tconstrained_colsR�tconstrained_col((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRp�s6
























c
CsVy|j|
|�}Wnt
k
r*


dSXx$|D]}	|jtj|	��

q2WdS(
N(R^R�R�R�tCheckConstraint(
RRORR`RyRsRtRcR�R�((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRq�s





cCsDy|j|
|�}Wnt
k
r*


dSX|jd
d�|_dS(NR�(R]R�RRR�(RRORR`Rctcomment_dict((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRr�s




(s1.0s�The :paramref:`get_table_names.order_by` parameter is deprecated and will be removed in a future release.  Please refer to :meth:`.Inspector.get_sorted_table_and_fkc_names` for a more comprehensive solution to resolving foreign key cycles between tables.N((0Rt
__module__t__doc__R'tclassmethodR*Rt	_inspectsRR+tpropertyR,R-Rtdeprecated_paramsRR/RKRLRMRNRPRQRTRRZRYR3R[R\R]R^RjR{RkR�RmRnRtasc_optdesc_opt
nullsfirst_optnullslast_opR�RoRpRqRr(((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR =sT		
	
*8	
	
(

#(

�	9			I


	:	3	N(R�tbaseRtR
RRRRRR�tsql.type_apiRRR	t	decoratorRtobjectR (((sO/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt<module>s