zmc
2023-12-22 9fdbf60165db0400c2e8e6be2dc6e88138ac719a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
U
¸ý°djÂã    @s¶dZddlmZddlmZddlZddlmZddlZddlm    Z    ddlm
Z
ddlm Z dd    lm Z dd
lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl m#Z#ddl$m%Z%dd l$m&Z&dd!l'm(Z(dd"l)m*Z*dd#l+m,Z,dd$l+m-Z-dd%l+m.Z.dd&l+m/Z/dd'l+m0Z0dd(l+m1Z1dd)l+m2Z2dd*l+m3Z3dd+l+m4Z4dd,l+m5Z5dd-l+m6Z6dd.l+m7Z7dd/l+m8Z8dd0l9m:Z:dd1l;m<Z<dd2l;m=Z=dd3l;m>Z>dd4l;m?Z?dd5l;m@Z@dd6l;mAZAdd7l;mBZBdd8lmCZCd9d:lmDZDd9d;lmEZEd9d<lFmGZGd9d=lFmHZHejrˆdd>lmIZIdd?lmJZJdd@lmKZKddAl+mLZLddBl+mMZMddCl;mNZNddDl;mOZOddEl;mPZPddFlmQZQddGlmRZRddHlmSZSd9dIlTmUZUd9dJlTmVZVd9dKlTmWZWd9dLlTmXZXd9dMlYmZZZedNdOdPZ[d¾dQdQdRdSdTdUœdVdW„Z\dXdQdYdZœd[d\„Z]d]dQdYd^œd_d`„Z^d]dadbdYdcœddde„Z_dfdOdgdhœdidj„Z`dkdkdkdkdkdlœdmdndndndndndodpœdqdr„Zadsdt„Zbdudv„Zcdwdx„Zddydz„ZedQd{d|œd}d~„Zfdd€„Zgdd‚„Zhdƒd„„ZidQdQdnd…œd†d‡„Zjdˆd‰„ZkdŠd‹„ZlGdŒd„dƒZmdŽd„ZnGdd‘„d‘emƒZoGd’d“„d“epƒZqGd”d•„d•emƒZrdNd–dNd—œd˜d™„Zsd¿dRdRdRdRdšœd›dœ„ZteddždndŸd œd¡d¢„ƒZued£dždnd¤d œd¥d¢„ƒZud£dždnd¦d œd§d¢„ZudÀd¨d©„ZvGdªd«„d«ejwƒZxGd¬d­„d­eHƒZyGd®d¯„d¯exƒZzdÁd°d±d²d³d´œdµd¶„Z{d°d°d|œd·d¸„Z|d°d°d¹d¹dºd»œd¼d½„Z}dS)Âz;High level utilities which build upon other modules here.
 
é)Ú annotations)ÚdequeN)Úchain)Ú AbstractSet)ÚAny)ÚCallable)Úcast)Ú
Collection)ÚDict)ÚIterable)ÚIterator)ÚList)ÚOptional)Úoverload)ÚSequence)ÚTuple)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné)Ú    coercions)Ú    operators)Úroles)Úvisitors©Úis_text_clause)Ú_deep_annotate)Ú_deep_deannotate)Ú_shallow_annotate)Ú_expand_cloned)Ú _from_objects)Ú HasCacheKey)Ú sort_tables)Ú _find_columns)Ú_label_reference)Ú_textual_label_reference)Ú BindParameter)Ú ClauseElement)Ú ColumnClause)Ú ColumnElement)ÚGrouping)ÚKeyedColumnElement)ÚLabel)Ú NamedColumn)ÚNull)ÚUnaryExpression)ÚColumn)ÚAlias)Ú
FromClause)Ú FromGrouping)ÚJoin)Ú ScalarSelect)Ú
SelectBase)Ú TableClause)Ú_ETé)Úexc)Úutil)ÚLiteral)ÚProtocol)Ú_EquivalentColumnMap)Ú_LimitOffsetType)Ú_TypeEngineArgument)ÚBinaryExpression)Ú
TextClause)Ú_JoinTargetElement)Ú_SelectIterable)Ú
Selectable)Ú_TraverseCallableType)ÚExternallyTraversible)ÚExternalTraversal)Ú_AnyExecuteParams)Ú_AnyMultiExecuteParams)Ú_AnySingleExecuteParams)Ú_CoreSingleExecuteParams)ÚRowÚ_CEúColumnElement[Any])Úboundr2zOptional[FromClause]z(Optional[AbstractSet[ColumnClause[Any]]]zColumnElement[bool])ÚaÚbÚa_subsetÚconsider_as_foreign_keysÚreturncCstj||||dS)aCreate a join condition between two tables or selectables.
 
    e.g.::
 
        join_condition(tablea, tableb)
 
    would produce an expression along the lines of::
 
        tablea.c.id==tableb.c.tablea_id
 
    The join is determined based on the foreign key relationships
    between the two selectables.   If there are multiple ways
    to join, or no way to join, an error is raised.
 
    :param a_subset: An optional expression that is a sub-component
        of ``a``.  An attempt will be made to join to just this sub-component
        first before looking at the full ``a`` construct, and if found
        will be successful even if there are other ways to join to ``a``.
        This allows the "right side" of a join to be passed thereby
        providing a "natural join".
 
    )rSrT)r4Z_join_condition)rQrRrSrT©rVúJd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/sql/util.pyÚjoin_condition_s ürXzList[FromClause]z    List[int])ÚclausesÚjoin_torUcCsDtt|ƒƒ}g}t|ƒD]&\}}|D]}| |¡r$| |¡q$q|S)a”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
 
    )Úlistr Ú    enumerateÚis_derived_fromÚappend)rYrZÚ selectablesÚidxÚiÚfÚsrVrVrWÚfind_join_sourceƒs 
rdzSequence[FromClause])rYÚ    join_fromrUc    Cs tt|ƒƒ}g}t|ƒD]*\}}|D]}| |¡r$| |¡qq$qt|ƒdkrœg}|D]:}||}|D](}tt|ƒƒ t|ƒ¡rh| |¡qXqhqX|rœ|S|S)zŽGiven a list of FROM clauses and a selectable,
    return the indexes from the list of
    clauses which is derived from the selectable.
 
    r)    r[r r\r]r^ÚlenÚsetÚsurface_selectablesÚ intersection)    rYrer_Z liberal_idxrarbrcZconservative_idxr`rVrVrWÚ#find_left_clause_that_matches_givenŸs(     
 
  ÿ
rjrCúOptional[ColumnElement[Any]])rYrZÚonclauserUc
sg}tt|ƒƒ}tˆƒdkr2|dk    r2d}t|ƒ}nd}d}tˆƒD]t\}}| |g¡D]^}    |r’|dk    sjt‚t|jƒ |    j¡     |¡r´| 
|¡qBqV|dk    s¦t   ||    ¡rV| 
|¡qBqVqBt|ƒdkrîtt dd„ˆDƒŽƒ‰‡‡fdd„|Dƒ}|s|dk    rtttˆƒƒƒS|SdS)a Given a list of FROM clauses, a selectable,
    and optional ON clause, return a list of integer indexes from the
    clauses list indicating the clauses that can be joined from.
 
    The presence of an "onclause" indicates that at least one clause can
    definitely be joined from; if the list of clauses is of length one
    and the onclause is given, returns that index.   If the list of clauses
    is more than length one, and the onclause is given, attempts to locate
    which clauses contain the same columns.
 
    rNTFcSsg|]}t|jƒ‘qSrV)rZ _hide_froms)Ú.0rbrVrVrWÚ
<listcomp>øsz1find_left_clause_to_join_from.<locals>.<listcomp>csg|]}ˆ|ˆkr|‘qSrVrV)rmra©rYZtoremoverVrWrnús )rgr rfr#r\Ú
differenceÚAssertionErrorÚcÚunionÚ
issupersetr^r4Z    _can_joinrr[Úrange)
rYrZrlr`r_Zresolve_ambiguityZcols_in_onclauserarbrcrVrorWÚfind_left_clause_to_join_fromËs2 
 
 
 ÿrvzOCallable[[BinaryExpression[Any], ColumnElement[Any], ColumnElement[Any]], None]ÚNone)ÚfnÚexprrUcs0g‰dddœ‡‡‡fdd„ ‰tˆ|ƒƒd‰dS)aý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.
 
    r'zIterator[ColumnElement[Any]])ÚelementrUc3s¶t|tƒr|Vn |jdkr†t |j¡r†ˆ d|¡ˆ|jƒD]$}ˆ|jƒD]}ˆˆd||ƒqLq>ˆ     d¡| 
¡D] }ˆ|ƒqvn,t|t ƒr–|V| 
¡D]}ˆ|ƒEdHqždS)NÚbinaryr) Ú
isinstancer5Z__visit_name__rZ is_comparisonÚoperatorÚinsertÚleftÚrightÚpopÚ get_childrenr()rzÚlÚrÚelem©rxÚstackÚvisitrVrWrˆ.s 
ÿ 
 
 z#visit_binary_product.<locals>.visitN)r[)rxryrVr†rWÚvisit_binary_products( r‰F)Ú check_columnsÚinclude_aliasesÚ include_joinsÚinclude_selectsÚ include_crudr'ÚboolzList[TableClause])ÚclauserŠr‹rŒrrŽrUcsªg‰i}|rˆj|d<|d<|r,ˆj|d<|rRˆj|d<|d<|d<|d<|rv‡fdd    „|d
<|d <|d <|rއfd d„}||d<ˆj|d<t |i|¡ˆS)z1locate Table objects within the given expression.ÚselectZcompound_selectÚjoinÚaliasZsubqueryZ tablesampleZlateralcs ˆ |j¡S©N©r^Útable)Úent©ZtablesrVrWÚ<lambda>cózfind_tables.<locals>.<lambda>r~ÚupdateÚdeletecsˆ |j¡dSr”r•)Úcolumnr˜rVrWÚ visit_columngsz!find_tables.<locals>.visit_columnrr–)r^rÚtraverse)rrŠr‹rŒrrŽZ    _visitorsržrVr˜rWÚ find_tablesGs. 
þÿ
þÿ 
r cCsàt ¡}g}t|gƒ}|rÜ| ¡}t|tƒrÂt|tƒrBt |j    ¡sÂt|t
ƒr|t|j t ƒs||j }t|t ƒrn|j }| |¡qnt|tƒr˜|j }| |¡qt|tƒr¤q||krÚ| |¡| |¡q| ¡D]}| |¡qÊq|S)zqBreak up an 'order by' expression into individual column-expressions,
    without DESC/ASC/NULLS FIRST/NULLS LAST)r;Ú
column_setrÚpopleftr|r)r/rZis_ordering_modifierÚmodifierr,rzr5r*r^r$r%Úaddr‚)rÚcolsÚresultr‡ÚtrrrVrVrWÚunwrap_order_byrs>
 
ÿ
þ ÿ
 
 
 
 
 
  r¨cCs ddddœdd„}t |i|¡S)NrGrúOptional[ExternallyTraversible])rzÚkwrUc[s*t|tƒr|jSt|tƒr&ds&tdƒ‚dS)NFz&can't unwrap a textual label reference)r|r$rzr%rq)rzrªrVrVrWÚreplace¢s
 
 
 z'unwrap_label_reference.<locals>.replace)rZreplacement_traverse)rzr«rVrVrWÚunwrap_label_reference¡s    r¬cs6dd„|Dƒ‰ttdd„|DƒŽƒ}‡fdd„|DƒS)zÜGiven the columns clause and ORDER BY of a selectable,
    return a list of column expressions that can be added to the collist
    corresponding to the ORDER BY, without repeating those already
    in the collist.
 
    cSs h|]}|jdk    r|jn|’qSr”)Z_order_by_label_elementrz©rmÚcolrVrVrWÚ    <setcomp>µsÿz3expand_column_list_from_order_by.<locals>.<setcomp>cSsg|] }t|ƒ‘qSrV)r¨)rmÚorVrVrWrnºsz4expand_column_list_from_order_by.<locals>.<listcomp>csg|]}|ˆkr|‘qSrVrVr­©Zcols_already_presentrVrWrn¼s)r[r)ZcollistZorder_byZ to_look_forrVr±rWÚ expand_column_list_from_order_by®s
þr²cCs t|ƒD]}||krdSqdS)zÐ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.
 
    TFN)rh)rÚsearchr…rVrVrWÚclause_is_present¿s     r´zIterator[FromClause])rrUccsRt|tƒr,t|jƒEdHt|jƒEdHn"t|tƒrHt|jƒEdHn|VdSr”)r|r4Útables_from_leftmostrr€r3rz)rrVrVrWrµÏs 
 
rµccsR|g}|rN| ¡}|Vt|tƒr6| |j|jf¡qt|tƒr| |j¡qdSr”)    rr|r4Úextendrr€r3r^rz©rr‡r…rVrVrWrhÙs
 
rhccsš|g}|r–| ¡}t|ttfƒr&|Vt|tƒrD| |j|jf¡qt|tƒr\|     |j
¡qt|t ƒr†|j dk    r~|     |j ¡q”|Vq|dk    r|VqdSr”) rr|r7r1r4r¶rr€r3r^rzr(r–r·rVrVrWÚsurface_selectables_onlyäs
 
 
 
r¸cCs\ttf}t|gƒ}|rX| ¡}||jkr2|j|S| ¡D]}t||ƒrJq:| |¡q:qdSr”)r3r6rr¢Ú _annotationsr‚r|r^)rZannotation_nameZfilter_r‡r…ÚsubrVrVrWÚextract_first_column_annotation÷s
 
 
 
r»)rr€rUcCsttt|ƒƒ t|ƒ¡ƒS)z:Return True if left/right have some overlapping selectable)rrgrhri)rr€rVrVrWÚselectables_overlapsÿr¼cs&g‰‡fdd„}t |id|i¡ˆS)zÑ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]
    csˆ |j¡dSr”)r^Zeffective_value)Úbind©ÚvrVrWÚvisit_bindparamsz$bind_values.<locals>.visit_bindparamZ    bindparam)rrŸ)rrÀrVr¾rWÚ bind_valuess  rÁcCs*t|tƒr| dd¡}d|St|ƒSdS)Nú'z''z'%s')r|Ústrr«Úrepr)rzrVrVrWÚ_quote_ddl_expr#s
 rÅc@sNeZdZUdZded<dZded<dZded<dZded    <d
d d œd d„ZdS)Ú
_repr_baserÚintÚ_LISTrÚ_TUPLEr9Ú_DICT)Ú    max_charsrËrrÃ)ÚvaluerUcCsPt|ƒ}t|ƒ}||jkrL|jd}|d|…d||j|| d…}|S)Nr9rz# ... (%d characters truncated) ... )rÄrfrË)ÚselfrÌÚrepZlenrepZsegment_lengthrVrVrWÚtrunc4s
 
 
ÿþ ûÿz_repr_base.truncN)    Ú__name__Ú
__module__Ú __qualname__rÈÚ__annotations__rÉrÊÚ    __slots__rÏrVrVrVrWrÆ+s
   rÆcCstƒ}d|_| |¡S)Né,)rÆrËrÏ)rÌÚrprVrVrWÚ_repr_single_valueDsr×c@s4eZdZdZdZddddœdd„Zd    d
œd d „Zd S)Ú    _repr_rowzProvide a string view of a row.)ÚrowrÕzRow[Any]rÇ©rÙrËcCs||_||_dSr”rÚ)rÍrÙrËrVrVrWÚ__init__Osz_repr_row.__init__rérUcs:|j‰dd ‡fdd„|jDƒ¡t|jƒdkr2dndfS)Nú(%s%s)ú, c3s|]}ˆ|ƒVqdSr”rV©rmrÌ©rÏrVrWÚ    <genexpr>Vsz%_repr_row.__repr__.<locals>.<genexpr>rú,Ú)rÏr’rÙrf©rÍrVràrWÚ__repr__Ss
þz_repr_row.__repr__N)rÕ)rÐrÑrÒÚ__doc__rÔrÛrårVrVrVrWrØJsrØc@seZdZddœdd„ZdS)Ú_long_statementrÃrÜcCsXt|ƒ}|dkrJd}d}|||}|d|…›d|›d|| d…›St |¡SdS)Niôéúédrú ... z characters truncated ... )rfrÃÚ__str__)rÍZlselfÚlleftZlrightrÏrVrVrWrë\s $ÿz_long_statement.__str__N)rÐrÑrÒrërVrVrVrWrç[srçc@sžeZdZdZdZd%dddddd    œd
d „Zd d œdd„Zddd dœdd„Zdddœdd„Zddd dœdd„Z    dd dœdd„Z
d d dœd!d"„Z dd dœd#d$„Z dS)&Ú _repr_paramsz°Provide a string view of bound parameters.
 
    Truncates display to a given number of 'multi' parameter sets,
    as well as long values to a given number of characters.
 
    )ÚparamsÚbatchesÚismultiÚ
max_paramsrérÕNzOptional[_AnyExecuteParams]rÇzOptional[bool])rîrïrñrËrðcCs"||_||_||_||_||_dSr”)rîrðrïrËrñ)rÍrîrïrñrËrðrVrVrWrÛts
z_repr_params.__init__rÃrÜc    Cs|jdkr| |j¡St|jtƒr*|j}n4t|jtƒr>|j}n t|jtƒrR|j    }n | |j¡S|jrèt
d|jƒ}t |jƒ|j krÚd}d  | |d|j d…|¡dd…||j t |jƒf| |dd…|¡dd…f¡S| ||¡Sn| t
d    |jƒ|¡SdS)
NrJz8 ... displaying %i of %i total bound parameter sets ... ú r9réÿÿÿÿéþÿÿÿrrK)rðrÏrîr|r[rÈÚtuplerÉÚdictrÊrrfrïr’Ú _repr_multirí)rÍÚtypÚ multi_paramsÚmsgrVrVrWrå‚sJ
     þÿþýúÿ þûz_repr_params.__repr__rJ)rùrørUcsœ|rzt|dtƒrˆj‰nDt|dtƒr0ˆj‰n.t|dtƒrFˆj‰nds^tdt|dƒƒ‚d     ‡‡fdd„|Dƒ¡}nd}|ˆjkrd|Sd    |SdS)
NrFzUnknown parameter type %srÞc3s|]}ˆ |ˆ¡VqdSr”)rí)rmrî©Z    elem_typerÍrVrWráÀsz+_repr_params._repr_multi.<locals>.<genexpr>rãú[%s]z(%s))
r|r[rÈrõrÉrörÊrqÚtyper’)rÍrùrøÚelementsrVrûrWr÷¯s"
ÿÿ
 
z_repr_params._repr_multiz Iterable[Any]r)rîrUcCsTt|ƒ}t|ƒ}||jkrF|jd}|d|…|| d…||jfS|ddfSdS)Nr9r)r[rfrñ)rÍrîZlparamsZ    lenparamsrìrVrVrWÚ _get_batchesËs
 
 
 ýz_repr_params._get_batchesrK)rîrørUcCsB||jkr| td|ƒ¡S||jkr4| td|ƒ¡S| |¡SdS)NrLú Sequence[Any])rÊÚ_repr_param_dictrrÉÚ_repr_param_tupleÚ_repr_param_list)rÍrîrørVrVrWríØs
ÿ
z_repr_params._repr_paramsrLcsŒ|j‰| | ¡¡\}}}|rldd ‡fdd„|Dƒ¡}|d|›d7}|dd ‡fdd„|Dƒ¡7}nd    d ‡fd
d„|Dƒ¡}|S) Nz{%srÞc3s$|]\}}|›dˆ|ƒ›VqdS©z: NrV©rmÚkeyrÌràrVrWráðsÿz0_repr_params._repr_param_dict.<locals>.<genexpr>rêú parameters truncated ... z%s}c3s$|]\}}|›dˆ|ƒ›VqdSrrVrràrVrWrá÷sÿz{%s}c3s$|]\}}|›dˆ|ƒ›VqdSrrVrràrVrWráþsÿ)rÏrÿÚitemsr’©rÍrîZitems_first_batchZitems_second_batchZtrunclenÚtextrVràrWræs0 üþÿþÿþÿz_repr_params._repr_param_dictrcsž|j‰| |¡\}}}|rjdd ‡fdd„|Dƒ¡}|d|›d7}|dd ‡fdd„|Dƒ¡f7}n0d    d ‡fd
d„|Dƒ¡t|ƒd kr’d nd f}|S)Nz(%srÞc3s|]}ˆ|ƒVqdSr”rVrßràrVrWrász1_repr_params._repr_param_tuple.<locals>.<genexpr>rêrz%s)c3s|]}ˆ|ƒVqdSr”rVrßràrVrWrásrÝc3s|]}ˆ|ƒVqdSr”rVrßràrVrWrásrrârã)rÏrÿr’rfr    rVràrWrs&üÿÿ
þz_repr_params._repr_param_tuplecsˆ|j‰| |¡\}}}|rhdd ‡fdd„|Dƒ¡}|d|›d7}|dd ‡fdd„|Dƒ¡7}nd    d ‡fd
d„|Dƒ¡}|S) Nz[%srÞc3s|]}ˆ|ƒVqdSr”rVrßràrVrWrá'sz0_repr_params._repr_param_list.<locals>.<genexpr>rêrz%s]c3s|]}ˆ|ƒVqdSr”rVrßràrVrWrá+srüc3s|]}ˆ|ƒVqdSr”rVrßràrVrWrá/s)rÏrÿr’r    rVràrWrs$üÿÿÿz_repr_params._repr_param_list)rérÕN) rÐrÑrÒrærÔrÛrår÷rÿrírrrrVrVrVrWríjsú- rízCollection[Any])ÚcritÚnullsrUcs‡fdd„}t |id|i¡S)zWgiven criterion containing bind params, convert selected elements
    to IS NULL.
 
    csnt|jtƒr:|jjˆkr:|j|_tƒ|_tj|_tj    |_
n0t|jtƒrj|jjˆkrjtƒ|_tj|_tj    |_
dSr”) r|rr&Z_identifying_keyr€r.rÚis_r}Úis_notÚnegate©r{©r rVrWÚ visit_binary:s
ÿ
þ
 
ÿ
þz-adapt_criterion_to_null.<locals>.visit_binaryr{)rZcloned_traverse)r r rrVrrWÚadapt_criterion_to_null4s r)rr€Ústop_onrUcCs¢|dkr |S|dfg}t|ƒ}d}|rž| ¡\}}t|tƒrl||k    rl| ¡}| |j¡|_| |j|f¡n
| |¡}|dk    r|dk    sŠt    ‚||_|dkr"|}q"|Sr”)
Ú ClauseAdapterrr|r4Z_clonerŸrlr^rrq)rr€rr‡ÚadapterÚretZ    prevrightrVrVrWÚ splice_joinsOs$
 
 rzIterable[ColumnElement[Any]]zOptional[ClauseElement]zSequence[ColumnElement[Any]])ÚcolumnsrYrªrUcOsdSr”rV©rrYrªrVrVrWÚreduce_columnslsrrDz/Sequence[Union[ColumnElement[Any], TextClause]]cOsdSr”rVrrVrVrWrusz1Collection[Union[ColumnElement[Any], TextClause]]c s4| dd¡}| dd¡‰t |¡}| dd„|Dƒ¡‰t ¡‰ˆD]¨}tdd„|jDƒŽD]Ž}ˆD]„}||krpqbz
|j}WnBtj    k
rœ|r–Yqbn‚Yn"tj
k
r¼|r¶Yqbn‚YnX|  |¡rbˆrØ|j |j krbˆ  |¡qZqbqZqB|r*‡‡‡fdd    „}    |D]"}
|
d
k    rt |
id |    i¡q| ˆ¡S) aCgiven 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.
 
    Úignore_nonexistent_tablesFÚ only_synonymscss|]}t|ƒr|VqdSr”r©rmrrrVrVrWrášsz!reduce_columns.<locals>.<genexpr>cSsg|]
}|j‘qSrV)Z foreign_keysrrVrVrWrn sz"reduce_columns.<locals>.<listcomp>cs||jtjkrxt tdd„ˆ ˆ¡DƒŽ¡}|j|krx|j|krxt    ˆƒD]0}| 
|j¡rFˆrh|j |jj krFˆ  |¡qxqFdS)NcSsg|]
}|j‘qSrV)Ú    proxy_setrrVrVrWrnÀsz8reduce_columns.<locals>.visit_binary.<locals>.<listcomp>) r}rÚeqr;r¡rrprr€ÚreversedÚshares_lineageÚnamer¤)r{r¥rr©Z cset_no_textZomitrrVrWr¼s ÿÿ  ÿ ÿ
z$reduce_columns.<locals>.visit_binaryNr{)rr;Z
OrderedSetrpr¡rrrr:ZNoReferencedColumnErrorZNoReferencedTableErrorr"r#r¤rrŸ) rrYrªrr¡r®ZfkrrZfk_colrrrVr$rWr~sF  
 
ÿ
 
ÿ
ÿ
 
 
csHˆrˆrt d¡‚dd„‰‡‡‡‡‡fdd„}g‰t |id|i¡ˆS)z9traverse an expression and locate binary criterion pairs.zSCan only specify one of 'consider_as_foreign_keys' or 'consider_as_referenced_keys'cSs
| |¡Sr”)Úcompare)rQrRrVrVrWÚcol_isász"criterion_as_pairs.<locals>.col_iscs~ˆs|jtjk    rdSt|jtƒr,t|jtƒs0dSˆr |jˆkrjˆ|j|jƒsV|jˆkrjˆ |j|jf¡n4|jˆkržˆ|j|jƒsŒ|jˆkržˆ |j|jf¡nڈr|jˆkr܈|j|jƒsÈ|jˆkr܈ |j|jf¡n:|jˆkrzˆ|j|jƒs|jˆkrzˆ |j|jf¡nbt|jtƒrzt|jtƒrz|j     |j¡rXˆ |j|jf¡n"|j     |j¡rzˆ |j|jf¡dSr”)
r}rr r|rr)r€r^r0Z
referencesr©Ú any_operatorr&rTÚconsider_as_referenced_keysÚpairsrVrWråsRÿ
 ÿþ
 ÿþ
 ÿþ  ÿþÿz(criterion_as_pairs.<locals>.visit_binaryr{)r:Ú ArgumentErrorrrŸ)Z
expressionrTr)r(rrVr'rWÚcriterion_as_pairsÒsÿ'r,c    @s˜eZdZdZdZdddddddd    d
œd d „Zerhed ddœdd„ƒZedddœdd„ƒZdddœdd„Ze    j
fdd„Z e      d¡dddddœdd„ƒZ dS)ra5Clones 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
 
    )Ú__traverse_options__Ú
selectableÚ
include_fnÚ
exclude_fnÚ equivalentsÚadapt_on_namesÚadapt_from_selectablesNFrEúOptional[_EquivalentColumnMap]ú)Optional[Callable[[ClauseElement], bool]]rú!Optional[AbstractSet[FromClause]])r.r1r/r0r2Úanonymize_labelsr3cCs@|g|dœ|_||_||_||_t |p*i¡|_||_||_dS)N)rr7)    r-r.r/r0r;Z column_dictr1r2r3)rÍr.r1r/r0r2r7r3rVrVrWrÛ6s þzClauseAdapter.__init__ú Literal[None]rw©ÚobjrUcCsdSr”rV©rÍr:rVrVrWrŸMszClauseAdapter.traverser8cCsdSr”rVr;rVrVrWrŸYsr©cCsdSr”rVr;rVrVrWrŸ]scCsŽ|jj||d}|dkrb||jkrb||krb|j|D],}|j||| |g¡d}|dk    r4|Sq4|jrŠ|dkrŠt|tƒrŠ|jj     |j
¡}|S)N©Úrequire_embedded)r=Ú_seen) r.Úcorresponding_columnr1Ú_corresponding_columnrsr2r|r-Zexported_columnsÚgetr#)rÍr®r=r>ÚnewcolÚequivrVrVrWr@bs*ÿ
ý
ÿþýz#ClauseAdapter._corresponding_columnzsqlalchemy.sql.functionsz Optional[_ET])r®Ú_include_singleton_constantsrUcCsBtjj}|jr| |¡sdS|jr0| |¡r0dSt|tƒrœt||jƒsœ|j     |¡r||j
rv|j
D]}|     |¡r^qvq^dS|jSt|t ƒr–t|j t ƒr–|SdSnt|tƒsªdS|s¸|jr¸dSd|jkrÌ|jd}trÞt|tƒsÞt‚|j
r||jkr|j
D] }|j |d¡dk    røqqødStr4t|tƒs4t‚|j|ddS)NZ adapt_columnFTr<)r;Z    preloadedZ sql_functionsr/r0r|r2ZFunctionElementr.r]r3r1rzr7r)Z_is_singleton_constantr¹rr+rqr1rrr?r@)rÍr®rDZ    functionsZadprVrVrWr«zsR ÿ 
 
 ÿ
 
 
 
 
 
 
ÿzClauseAdapter.replace)NNNFFN)F)rÐrÑrÒrærÔrÛrrrŸr;Ú    EMPTY_SETr@Zpreload_moduler«rVrVrVrWrs( ø ÿ
ÿrc@sleZdZedddœdd„ƒZedddœdd„ƒZedddœdd„ƒZed    d    dœd
d„ƒZd d dœd d„Zd S)Ú _ColumnLookuprw)rrUcCsdSr”rV©rÍrrVrVrWÚ __getitem__Åsz_ColumnLookup.__getitem__zColumnClause[Any]cCsdSr”rVrGrVrVrWrHÉsrOcCsdSr”rVrGrVrVrWrHÍsr8cCsdSr”rVrGrVrVrWrHÑsrcCsdSr”rVrGrVrVrWrHÕsN)rÐrÑrÒrrHrVrVrVrWrFÄsrFc sèeZdZUdZdZded<d,dd    d
d d d
d
d
d d œ    ‡fdd„ ZGdd„dƒZdd„Ze    dddœdd„ƒZ
e    dddœdd„ƒZ
dddœdd„Z
dddœ‡fdd „ Z e r¶e d!d"œd#d$„ƒZe
ZejZd%d&d'œd(d)„Zd%d&d'œd*d+„Z‡ZS)-Ú ColumnAdapteraƒ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
 
    )rÚadapt_requiredÚallow_label_resolveÚ_wrapÚ __weakref__rFrNFTrEr4rr5r6)    r.r1rJr/r0r2rKr7r3c
 
    sZtƒj|||||||    dt |j¡|_|js4|jrD| ||j¡|_||_    ||_
d|_ dS)N)r/r0r2r7r3) ÚsuperrÛr;ÚWeakPopulateDictÚ _locate_colrr/r0Ú_IncludeExcludeMappingrJrKrL)
rÍr.r1rJr/r0r2rKr7r3©Ú    __class__rVrWrÛs ù
 zColumnAdapter.__init__c@seZdZdd„Zdd„ZdS)z$ColumnAdapter._IncludeExcludeMappingcCs||_||_dSr”)Úparentr)rÍrTrrVrVrWrÛ sz-ColumnAdapter._IncludeExcludeMapping.__init__cCsL|jjr|j |¡r(|jjrB|j |¡rB|jjr>|jjj|S|S|j|Sr”)rTr/r0rLrrGrVrVrWrH$sÿ
ÿþ
þz0ColumnAdapter._IncludeExcludeMapping.__getitem__N)rÐrÑrÒrÛrHrVrVrVrWrQsrQcCs>t |¡}||_t |j¡|_|js*|jr:| ||j¡|_|Sr”)    ÚcopyrLr;rOrPrr/r0rQ)rÍrÚacrVrVrWÚwrap.s 
 zColumnAdapter.wrapr8rwr9cCsdSr”rVr;rVrVrWrŸ7szColumnAdapter.traverser8cCsdSr”rVr;rVrVrWrŸ;sr©cCs
|j|Sr”)rr;rVrVrWrŸ?srH)ÚvisitorrUcst|tƒst‚tƒ |¡Sr”)r|rIrqrNr)rÍrXrRrVrWrDszColumnAdapter.chainzIterator[ColumnAdapter]rÜcCsdSr”rVrärVrVrWÚvisitor_iteratorKszColumnAdapter.visitor_iteratorrOrk)r®rUcCs*|j|}||kr&| |d¡dkr&dS|S)NT)rr@)rÍr®rBrVrVrWÚadapt_check_presentRs
z!ColumnAdapter.adapt_check_presentcCs‚|jr2|jD]}|j|dd}|dk    r q>q |}n t ||¡}|jr\|j |¡}|dk    r\|}|jrn||krndS||k    r~|j|_    |S)NT)rD)
Z _is_immutablerYr«rrŸrLrPrJrKZ_allow_label_resolve)rÍr®ZvisrrÚc2rVrVrWrP\s  
 
zColumnAdapter._locate_col)NFNNFTFN)rÐrÑrÒrærÔrÓrÛrQrWrrŸrrÚpropertyrYZ adapt_clauserZcopy_and_processZ
adapt_listrZrPÚ __classcell__rVrVrRrWrIÙs6
ö$    
rIr?z Optional[str]z"Optional[_TypeEngineArgument[int]]zColumnElement[int])rzr#Útype_rUcCstjtj|||dS)z½Convert the given value to an "offset or limit" clause.
 
    This handles incoming integers and converts to an expression; if
    an expression is already given, it is passed through.
 
    )r#r^)rÚexpectrZLimitOffsetRole)rzr#r^rVrVrWÚ_offset_or_limit_clause‰s ÿr`cCs.|dkr dSt|dƒr&|j}t |¡S|SdS)zdReturn the offset or limit clause as a simple integer if possible,
    else return the clause.
 
    NÚ_limit_offset_value)Úhasattrrar;Zasint)rrÌrVrVrWÚ)_offset_or_limit_clause_asint_if_possible™s 
 
rcrÇzATuple[Optional[ColumnElement[int]], Optional[ColumnElement[int]]])Ú limit_clauseÚ offset_clauseÚstartÚstoprUcCsÐ|dk    rd|dk    rdt|ƒ}|dkr$d}|dkr4||}|dkrBd}n|dk    sNt‚t|ƒ}t||ƒ}nd|dkr~|dk    r~t|ƒ}nJ|dk    rÈ|dkrÈt|ƒ}|dkr¢d}|dkr²||}|dkrÀd}nt|ƒ}||fS)z0Compute LIMIT/OFFSET in terms of slice start/endNr)rcrqr`)rdrerfrgrVrVrWÚ _make_slice©s:ÿ 
ÿÿrh)NN)N)NNF)NN)~ræÚ
__future__rÚ collectionsrrUÚ    itertoolsrÚtypingrrrrr    r
r r r rrrrrrrrãrrrrÚ_typingrÚ
annotationrrrÚbaserr Ú    cache_keyr!Zddlr"rþr#r$r%r&r'r(r)r*r+r,r-r.r/Zschemar0r.r1r2r3r4r5r6r7r8r:r;Z util.typingr<r=r>r?r@rArBrCrDrErFrGrHZengine.interfacesrIrJrKrLZ
engine.rowrMrNrXrdrjrvr‰r r¨r¬r²r´rµrhr¸r»r¼rÁrÅrÆr×rØrÃrçrírrrr,ZReplacingExternalTraversalrrFrIr`rcrhrVrVrVrWÚ<module>    s                                                                          ü$,9Fù+/ 
 KýVü
?43ý