ó
‹EYc@sdZd
dl
mZmZ
ddlmZmZ
ddl
mZmZ
ddl	m
Z

ddlmZ
dd	l
mZmZmZmZmZmZmZmZmZ
dd
lmZmZmZmZ
ddlmZ
ejjej dƒZ!dd
l"m#Z#m$Z$m%Z%
ddl
m&Z&
ddl'm(Z(
d„Z)d„Z*e+e+e+e+e+d„Z,d„Z-d„Z.d„Z/d„Z0d„Z1d„Z2d„Z3de4f
d„ƒYZ5d„Z6d$d„
Z8d„Z9d$d$e+d„Z:d ej;f
d!„ƒYZ<d"e<f
d#„ƒYZ=d$S(%s;High level utilities which build upon other modules here.

i(texctutili
(t
_from_objectst	ColumnSet(t	operatorstvisitorsiÿÿÿÿ(
tchain(
tdeque(	t
BindParametertColumnClauset
ColumnElementtNulltUnaryExpressiontliteral_columntLabelt_label_referencet_textual_label_reference(tScalarSelecttJoint
FromClausetFromGrouping(
tColumns.sql.util.join_condition(t_shallow_annotatet_deep_annotatet_deep_deannotate(
t
_find_columns(
tsort_tablescCsatt
|
ƒ
ƒ
}xHt|ƒ
D]6\}}x'|D]}|j|ƒ
r2||fSq2WqWdSd
S(s”
Given a list of FROM clauses and a selectable,
    return the first index and element from the list of
    clauses which can be joined against the selectable.  returns
    None, None if no match is found.

    e.g.::

        clause1 = table1.join(table2)
        clause2 = table4.join(table5)

        join_to = table2.join(table3)

        find_join_source([clause1, clause2], join_to) == clause1

    N(NN(tlistRt	enumeratetis_derived_fromtNone(tclausestjoin_totselectablest
it
ft
s((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytfind_join_source"s




cs/g‰
‡‡
‡fd
†‰tˆ|
ƒ
ƒ

dS(sýProduce a traversal of the given expression, delivering
    column comparisons to the given function.

    The function is of the form::

        def my_fn(binary, left, right)

    For each binary expression located which has a
    comparison operator, the product of "left" and
    "right" will be delivered to that function,
    in terms of that binary.

    Hence an expression like::

        and_(
            (a + b) == q + func.sum(e + f),
            j == r
        )

    would have the traversal::

        a <eq> q
        a <eq> e
        a <eq> f
        b <eq> q
        b <eq> e
        b <eq> f
        j <eq> r

    That is, every combination of "left" and
    "right" that doesn't further contain
    a binary comparison is passed as pairs.

    c
3s
t|t
ƒr|V
nô|jd
krÁtj|jƒ
rÁˆ
jd|ƒ
xEˆ|jƒ
D]4}
x+ˆ|jƒ
D]}ˆˆ
d|
|ƒ
qnWqXWˆ
j	dƒ

xk|j
ƒD]}ˆ|ƒ

qªWnJt|tƒrØ|V
nx0|j
ƒD]"}xˆ|ƒ
D]}|V
qøWqåWdS(Ntbinaryi(t
isinstanceRt__visit_name__Rt
is_comparisontoperatortinserttlefttrighttpoptget_childrenR	(telementt
lt
rtelemt
e(tfntstacktvisit(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR7as 














N(
R(R5texpr((R5R6R7sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytvisit_binary_product<s#csÏg‰i}|r*ˆj|d
<|d<n|r@ˆj|d<n|rVˆj|d<n|r‚‡f
d†|d<|d<|d<n|
r¤‡f
d	†}||d
<nˆj|d<t
j|i
td6|ƒ
ˆS(
s1locate Table objects within the given expression.tselecttcompound_selecttjointaliasc

sˆj|j
ƒ
S(
N(tappendttable(
tent(
ttables(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt<lambda>‹sR+tupdatetdeletec

sˆj|j
ƒ

dS(
N(R>R?(
tcolumn(
RA(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytvisit_columnŽs
RER?tcolumn_collections(R>RttraversetFalse(tclauset
check_columnstinclude_aliasest
include_joinstinclude_selectstinclude_crudt	_visitorsRF((
RAsH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytfind_tablesxs 



&



c
CsÎtj
ƒ}
t|g
ƒ
}x¬|rÉ|jƒ}t|tƒr¢t|tƒsbtj|j	ƒ
r¢t|t
ƒr}|j}nt|tƒr’qn|
j
|ƒ

qx!|jƒD]}|j|ƒ

q¯WqW|
S(
sqBreak up an 'order by' expression into individual column-expressions,
    without DESC/ASC/NULLS FIRST/NULLS LAST(R
t
column_setRtpopleftR'R
RRtis_ordering_modifiertmodifierRR0RtaddR/R>(RJtcolsR6t
tt
c((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytunwrap_order_by˜s

	








c
Csd
„}
tj
|i|
ƒS(Nc

Ss t|t
tfƒr|jSdS(
N(R'RRR0(
R3((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytreplace±s

(Rtreplacement_traverse(R0R[((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytunwrap_label_reference°s
	
cCs/x(t|
ƒ
D]}||kr
t
Sq
WtSd
S(sÐGiven a target clause and a second to search within, return True
    if the target is plainly present in the search without any
    subqueries or aliases involved.

    Basically descends through Joins.

    N(tsurface_selectablestTrueRI(RJtsearchR3((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytclause_is_presentºs	

c
csx|g
}
xh|
rs|
jƒ}|V
t
|tƒrN|
j|j|jfƒ

qt
|tƒr|
j|jƒ

qqWdS(
N(	R.R'RtextendR,R-RR>R0(RJR6R3((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR^Ês
	
	





cCs%tt
t|ƒ
ƒ
jt|
ƒ
ƒ
ƒ
S(
s:Return True if left/right have some overlapping selectable(tbooltsetR^tintersection(R,R-((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytselectables_overlapÕs

c
s3g‰‡f
d
†}
tj
|ii
|
d6ƒ
ˆS(sÑReturn an ordered list of "bound" values in the given clause.

    E.g.::

        >>> expr = and_(
        ...    table.c.foo==5, table.c.foo==7
        ... )
        >>> bind_values(expr)
        [5, 7]
    c

sˆj|j
ƒ

dS(
N(R>teffective_value(
tbind(
t
v(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytvisit_bindparamís
t	bindparam(RRH(RJRj((
RisH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytbind_valuesßs
c

Cs:t|t
jƒr,|jd
dƒ}d|St|ƒ
SdS(Nt
's''s'%s'(R'R
tstring_typesR[trepr(
R0((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt_quote_ddl_exprôs


t_repr_paramsc
Bs eZ
dZd
„Zd„ZRS(snA string view of bound parameters, truncating
    display to the given number of 'multi' parameter sets.

    cCs|
|_||_
dS(
N(tparamstbatches(tselfRrRs((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt__init__
s
	
c
Cs¾t|j
ttfƒr­t|j
ƒ
|jkr­t|j
d
tttfƒr­d}
djt|j
|jd ƒ
d
d!|
|jt|j
ƒ
ft|j
dƒ
dfƒ
St|j
ƒ
SdS(Nis8 ... displaying %i of %i total bound parameter sets ... t
 iiÿÿÿÿiþÿÿÿi
(	R'RrRttupletlenRstdictR<Ro(Rttmsg((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt__repr__
s







(t__name__t
__module__t__doc__RuR{(((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRqüs	cs)‡f
d
†}tj
|ii
|d6ƒS(sWgiven criterion containing bind params, convert selected elements
    to IS NULL.

    c

s¦t|j
tƒrW|j
jˆkrW|j|_
tƒ|_tj|_tj	|_
nKt|jtƒr¢|jjˆkr¢tƒ|_tj|_tj	|_
ndS(
N(R'R,Rt_identifying_keyR-RRtis_R*tisnottnegate(
R&(
tnulls(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytvisit_binary
s









R&(Rtcloned_traverse(tcritRƒR„((
RƒsH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytadapt_criterion_to_null
scCsï|dkr|
S|
dfg
}t
|ƒ
}d}x·|rê|jƒ\}
}t|
tƒr«|
|k	r«|
jƒ}
|
jƒ
|j|
jƒ
|
_|j	|
j
|
fƒ

n|j|
ƒ
}
|dk	rÒ|
|_
n|dkr4|
}q4q4W|S(
N(Rt
ClauseAdapterR.R'Rt_clonet_reset_exportedRHtonclauseR>R,(R,R-tstop_onR6tadaptertrett	prevright((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytsplice_joins+
s$



	











c

sœ
|jd
t
ƒ}|jdt
ƒ‰tjˆƒ
‰tjƒ‰
xïˆD]ç}xÞtg|jD]}|j^q\ŒD]·}x®ˆD]¦}||kr—qny
|j}WnEt	j
k
rÉ


|rÃqqì‚n#t	jk
rë


|råqqì‚n
X|j|ƒ
rˆs
|j
|j
krˆ
j|ƒ

PqqWqrWqFW|
r‰
‡‡
‡fd†}x:|
D]/}	|	dk	rS
tj|	ii
|d6ƒ
qS
qS
Wntˆjˆ
ƒ
ƒ
S(sCgiven a list of columns, return a 'reduced' set based on natural
    equivalents.

    the set is reduced to the smallest list of columns which have no natural
    equivalent present in the list.  A "natural equivalent" means that two
    columns will ultimately represent the same value because they are related
    by a foreign key.

    \*clauses is an optional list of join clauses which will be traversed
    to further identify columns that are "equivalent".

    \**kw may specify 'ignore_nonexistent_tables' to ignore foreign keys
    whose tables are not yet configured, or columns that aren't yet present.

    This function is primarily used to determine the most minimal "primary
    key" from a selectable, by reducing the set of primary key columns present
    in the selectable to just those that are not repeated.

    tignore_nonexistent_tablest
only_synonymsc
sÄ|jt
jkrÀtjtgˆjˆ
ƒ
D]}
|
j^q+Œƒ
}|j|krÀ|j	|krÀxVt
ˆƒ
D]E}
|
j|j	ƒ
rqˆs¥|
j|jjkrqˆ
j
|
ƒ

PqqqqWqÀndS(
N(R*RteqR
RRRt
differencet	proxy_setR,R-treversedtshares_lineagetnameRV(R&RYRW(tcolumnstomitR’(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR„z
s


.







R&N(R.RIR
tordered_column_setRRRR•tforeign_keysRERtNoReferencedColumnErrortNoReferencedTableErrorR—R˜RVRRRHRR”(
R™RtkwR‘tcolRYtfktfk_colR„RJ((R™RšR’sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytreduce_columnsD
s<



,




















$csfˆrˆrtj
d
ƒ
‚
nd„‰
‡‡
‡‡‡fd†}g‰tj|ii
|d6ƒ
ˆS(s9traverse an expression and locate binary criterion pairs.sSCan only specify one of 'consider_as_foreign_keys' or 'consider_as_referenced_keys'cSs
|j|
ƒ
S(
N(
tcompare(t
at
b((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytcol_is•
sc

	s"ˆr|jt
jk	rdSt|jtƒsCt|jtƒrGdSˆrî|jˆkrœˆ
|j|jƒs€|jˆkrœˆj|j|jfƒ

q|jˆkrˆ
|j|jƒsÏ|jˆkrˆj|j|jfƒ

qn0
ˆr•
|jˆkrC
ˆ
|j|jƒs'
|jˆkrC
ˆj|j|jfƒ

q|jˆkrˆ
|j|jƒsv
|jˆkrˆj|j|jfƒ

qn‰t|jtƒrt|jtƒr|jj	|jƒ
rê
ˆj|j|jfƒ

q|jj	|jƒ
rˆj|j|jfƒ

qndS(
N(
R*RR“R'R,R
R-R>Rt
references(
R&(tany_operatorR§tconsider_as_foreign_keystconsider_as_referenced_keystpairs(sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR„™
s:


























R&(Rt
ArgumentErrorRRH(t
expressionRªR«R©R„((R©R§RªR«R¬sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytcriterion_as_pairsŒ
s
	 

RˆcBs>eZ
dZdddeed
„Zejd„
Zd„Z	RS(s5Clones and modifies clauses based on column correspondence.

    E.g.::

      table1 = Table('sometable', metadata,
          Column('col1', Integer),
          Column('col2', Integer)
          )
      table2 = Table('someothertable', metadata,
          Column('col1', Integer),
          Column('col2', Integer)
          )

      condition = table1.c.col1 == table2.c.col1

    make an alias of table1::

      s = table1.alias('foo')

    calling ``ClauseAdapter(s).traverse(condition)`` converts
    condition to read::

      s.c.col1 == table2.c.col1

    cCsZi|
g
d
6|d6|_|
|_
||_||_tj|pDiƒ
|_||_dS(NRŒtanonymize_labels(t__traverse_options__t
selectablet
include_fnt
exclude_fnR
tcolumn_dicttequivalentstadapt_on_names(RtR²R¶R³R´R·R°((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRuÙ
s




	
	
	

c
CsÅ|jj
|
d
|ƒ

}|dkr‘|
|jkr‘|
|kr‘xO|j|
D]=}|j|d
|d|j|
g
ƒ
ƒ
}|dk	rM|SqMWn|jrÁ|dkrÁ|jjj|
j	ƒ
}n|S(Ntrequire_embeddedt_seen(
R²tcorresponding_columnRR¶t_corresponding_columntunionR·RYtgetR˜(RtR R¸R¹tnewcoltequiv((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR»å
s	

	
'








cCsˆt|
t
ƒr(|jj|
ƒ
r(|jSt|
tƒs;dS|jrX|j|
ƒ
rXdS|jrt|j|
ƒ
rtdS|j|
t	ƒSdS(
N(
R'RR²RR
RR³R´R»R_(RtR ((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyR[õ
s








N(
R|R}R~RRIRuR
t	EMPTY_SETR»R[(((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRˆ¾
s

t
ColumnAdapterc	BseZ
dZd	d	ed	d	eeed
„Zdef
d„ƒYZd„Z	d„Z
e
Zej
Zd„Zd„Zd„ZRS(
sƒExtends ClauseAdapter with extra utility functions.

    Key aspects of ColumnAdapter include:

    * Expressions that are adapted are stored in a persistent
      .columns collection; so that an expression E adapted into
      an expression E1, will return the same object E1 when adapted
      a second time.   This is important in particular for things like
      Label objects that are anonymized, so that the ColumnAdapter can
      be used to present a consistent "adapted" view of things.

    * Exclusion of items from the persistent collection based on
      include/exclude rules, but also independent of hash identity.
      This because "annotated" items all have the same hash identity as their
      parent.

    * "wrapping" capability is added, so that the replacement of an expression
      E can proceed through a series of adapters.  This differs from the
      visitor's "chaining" feature in that the resulting object is passed
      through all replacing functions unconditionally, rather than stopping
      at the first one that returns non-None.

    * An adapt_required option, used by eager loading to indicate that
      We don't trust a result row column that is not translated.
      This is to prevent a column from being interpreted as that
      of the child row in a self-referential scenario, see
      inheritance/test_basic.py->EagerTargetingTest.test_adapt_stringency

    c

Cs¢tj
||
|d
|d|d|d|	ƒ
|rA|j|ƒ

ntj|jƒ
|_|jsh|jrƒ|j	||jƒ|_n||_
||_d|_
dS(NR³R´R·R°(RˆRuRR
tpopulate_column_dictt_locate_colR™R³R´t_IncludeExcludeMappingtadapt_requiredtallow_label_resolveRt_wrap(
RtR²R¶tchain_toRÅR³R´R·RÆR°((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRu"s







	
	
RÄc
BseZ
d„Zd
„ZRS(cCs|
|_||_
dS(
N(tparentR™(RtRÉR™((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRu7s
	
cCsl|jj
r|jj
|
ƒ
s=|jjra|jj|
ƒ
ra|jjrZ|jjj|
S|
Sn|j|
S(
N(RÉR³R´RÇR™(Rttkey((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt__getitem__;s

(R|R}RuRË(((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRÄ6s
	cCsw|jj
|jƒ
}|jj|jƒ

|
|_tj|jƒ
|_|j	sX|j
rs|j||jƒ|_n|S(
N(t	__class__t__new__t__dict__RCRÇR
RÂRÃR™R³R´RÄ(RtRtac((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pytwrapGs


	


cCs|j|
S(
N(
R™(Rttobj((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRHQs
cCsntj
||
ƒ}|jrE|jj|ƒ
}|dk	rE|}qEn|jr^||
kr^dS|j|_|S(
N(RˆRHRÇRÃRRÅRÆt_allow_label_resolve(RtR RYtc2((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRÃWs	



c
Cs|jj
ƒ}
|
d
=|
S(NR™(RÎtcopy(Rtt
d((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt__getstate__gs


cCs)|jj
|
ƒ

tj|jƒ
|_dS(
N(RÎRCR
tPopulateDictRÃR™(Rttstate((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt__setstate__ls

N(R|R}R~RRIR_RutobjectRÄRÐRHtadapt_clauseRˆtcopy_and_processt
adapt_listRÃRÖRÙ(((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyRÁs




	
	
			N(>R~tRR
tbaseRRRRt	itertoolsRtcollectionsRtelementsRR	R
RRR
RRRR²RRRRtschemaRtlanghelperstpublic_factoryt_join_conditiontjoin_conditiont
annotationRRRRtddlRR%R9RIRQRZR]RaR^RfRlRpRÚRqR‡RRR£R¯tReplacingCloningVisitorRˆRÁ(((sH/home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/sql/util.pyt<module>
sD



@"
	

	

		<

		
			
				H
1E