-h[SrSSKrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r S S KJr S SKJr S SKJr S SKJr SrSrSr\R*"S5r\R*"S5r"SS\5r"SS\5rSrSrSrSrSrSr Sr!Sr""SS \RFRH5r%"S!S"\RFRH5r&\RN"S#5S$5r("S%S&\5r)"S'S(\5r*"S)S*\5r+"S+S,\5r,"S-S.\+5r-"S/S0\.5r/"S1S2\R`"\/55r1"S3S4\1\5r2"S5S6\ 5r3"S7S8\Rh\+5r5"S9S:\65r7"S;S<\5r8"S=S>\ 5r9"S?S@\5r:"SASB\:5r;"SCSD\Rx\:5r="SESF\R|5r?SJSGjr@SHrA\4SIjrBg)Kz4Foundational utilities common to many sql modules. N)roles)visitors) HasCacheKey)HasCopyInternals)MemoizedHasCacheKey) ClauseVisitor)ExtendedInternalTraversal)InternalTraversal)exc)util) HasMemoized) hybridmethodPARSE_AUTOCOMMITNO_ARGc4\rSrSrSrSrSrSrSrSr Sr g ) Immutable'z@mark a ClauseElement as 'immutable' when expressions are cloned.Tc[S5eNz(Immutable objects do not support copyingNotImplementedErrorself optionaldictkwargss hC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\sqlalchemy/sql/base.py unique_paramsImmutable.unique_params,!"LMMc[S5errrs rparamsImmutable.params/r!r"c U$Nrkws r_cloneImmutable._clone2s r"c gr'r(r)s r_copy_internalsImmutable._copy_internals5s r"r(N) __name__ __module__ __qualname____firstlineno____doc__ _is_immutablerr$r+r.__static_attributes__r(r"rrr's JMNN r"rc2\rSrSrSrSrSr\S5rSr g)SingletonConstant9z.Represent SQL constants like NULL, TRUE, FALSETcUR$r') _singleton)clsargr*s r__new__SingletonConstant.__new__>s ~~r"c|[RU5nUR5 [U/5UlXlgr')objectr>__init__ frozenset proxy_setr;)r<objs r_create_singleton#SingletonConstant._create_singletonAs.nnS! "3%( r"r(N) r0r1r2r3r4_is_singleton_constantr> classmethodrFr6r(r"rr8r89s$8!  r"r8c~[RRUVs/sHoRPM sn5$s snfr') itertoolschain from_iterable _from_objects)elementselements rrNrNQs2 ?? ( (.67h7  h7 7:c~[RRUVs/sHoRPM sn5$s snf)zPexpand tables into individual columns in the given list of column expressions. )rKrLrM_select_iterable)rOcs r_select_iterablesrUWs4 ?? ( (%-.X  X. .rQcN[RS5nU"U5nXlU$)znon-caching _generative() decorator. This is basically the legacy decorator that copies the object and runs a method on the new copy. cRUR5nU"U/UQ70UD6nUbS5eU$)zMark a method as generative.z,generative methods must have no return value) _generate)fnrargsr*xs r _generative _generative.._generativeis9~~ t !d !b !yHHHy r")r decoratornon_generative)rYr\ decorateds rr\r\as1 ^^BI! r"c ^^URS05mURS05nUVs/sH,nU[R"U5URUS54PM. snm[R UU4Sj5nU$s snf)Nmsgsdefaultsc >USnUSSnTHVupEnU"U5ULdMT RUSUR<SUR<S35n[R"U5e U"U/UQ70UD6$)NrrzMethod z$() has already been invoked on this z construct)getr0 __class__r InvalidRequestError) rYrZr*rnamegetterdefault_msggettersrbs rcheck!_exclusive_against..checksAwABx&- "D(d|8+hh{{DNN4 --c22'.$$$$$r")popoperator attrgetterrerr^)namesr*rcrhrmrlrbs @@r_exclusive_againstrsws 66&" Dvvj"%HD x""4((,,tT*BCG  ^^ % % L+s3A=c &UR"S0UD6$Nr()r+)rPr*s rr+r+s >> B r"cf[R"UVs/sHoRPM sn6$s snf)zTexpand the given set of ClauseElements to be the set of all 'cloned' predecessors. )rKrL _cloned_set)rOr[s r_expand_clonedrxs' ??H=Hq]]H= >>=s.c^[[U55R[U55m[U4SjU55$)zreturn the intersection of sets a and b, counting any overlap between 'cloned' predecessors. The returned set is in terms of the entities present within 'a'. c3l># UH)nTRUR5(dM%Uv M+ g7fr' intersectionrw.0elem all_overlaps r '_cloned_intersection..s)k66t7G7GH$4 4setrxr|abrs @r_cloned_intersectionrs>nQ'(55nQ6GHK  r"c^[[U55R[U55m[U4SjU55$)Nc3l># UH)nTRUR5(aM%Uv M+ g7fr'r{r}s rr%_cloned_difference..s)+":":4;K;K"Lrrrs @r_cloned_differencers<nQ'(55nQ6GHK  r"cB\rSrSrSrSrSrSrSrSr Sr S r S r g ) _DialectArgViewzYA dictionary view of dialect-level arguments in the form _. cXlgr'rE)rrEs rrB_DialectArgView.__init__sr"cURSS5up#X#4$![a(n[R"[ U5US9 SnAgSnAff=f)N_rreplace_context)split ValueErrorrraise_KeyError)rkeydialect value_keyerrs r_key_DialectArgView._keysI &!$3!2 G% % < KK s ; !$$ < KK s ; _r)rrErrrrr ArgumentError)rrvaluerrrs r __setitem___DialectArgView.__setitem__sf A!%3 G.s% 9 "" # #9s"$)sumrErvaluesrs r__len___DialectArgView.__len__s/ 00779   r"cD^U4SjTRR5$)Nc3># UH9nTRRURHnU<SU<3v M M; g7f)rN)rErr)r~ dialect_name value_namers rr+_DialectArgView.__iter__..sH 8 "hh66m $Z 0 1 8sAA)rErrs`r__iter___DialectArgView.__iter__s $ 8 8  r"rN) r0r1r2r3r4rBrrrrrrr6r(r"rrrs+ &" A9  r"rc<\rSrSrSrSrSrSrSrSr Sr S r g ) _DialectArgDictzA dictionary view of dialect-level arguments for a specific dialect. Maintains a separate collection of user-specified arguments and dialect-specified default arguments. c 0Ul0Ulgr'r _defaultsrs rrB_DialectArgDict.__init__sr"cp[[UR5RUR55$r')rrrunionrrs rr_DialectArgDict.__len__s'3t))*00@AAr"cp[[UR5RUR55$r')iterrrrrrs rr_DialectArgDict.__iter__s'C**+11$..ABBr"c\XR;aURU$URU$r'rrrs rr_DialectArgDict.__getitem__s. $$ $%%c* *>>#& &r"c X RU'gr'rrrrs rr_DialectArgDict.__setitem__ s"'3r"cURU gr'rrs rr_DialectArgDict.__delitem__ s   s #r")rrN) r0r1r2r3r4rBrrrrrr6r(r"rrrs'BC' ($r"rzsqlalchemy.dialectsc[RRRR U5nUR cg[ UR 5$r')r preloadeddialectsregistryloadconstruct_argumentsdict)r dialect_clss r_kw_reg_for_dialectrsB..))2277 EK&&.  // 00r"c\rSrSrSrS\R 4/r\S5r \ RS5r \ S5r\ R"\5rSr\ RS5rS rS rg ) DialectKWArgsia!Establish the ability for a class to have dialect-specific arguments with defaults and constructor validation. The :class:`.DialectKWArgs` interacts with the :attr:`.DefaultDialect.construct_arguments` present on a dialect. .. seealso:: :attr:`.DefaultDialect.construct_arguments` rc[RUnUc[R"SU-5eX;a0X@'X4UU'g)aAdd a new kind of dialect-specific keyword argument for this class. E.g.:: Index.argument_for("mydialect", "length", None) some_index = Index('a', 'b', mydialect_length=5) The :meth:`.DialectKWArgs.argument_for` method is a per-argument way adding extra arguments to the :attr:`.DefaultDialect.construct_arguments` dictionary. This dictionary provides a list of argument names accepted by various schema-level constructs on behalf of a dialect. New dialects should typically specify this dictionary all at once as a data member of the dialect class. The use case for ad-hoc addition of argument names is typically for end-user code that is also using a custom compilation scheme which consumes the additional arguments. :param dialect_name: name of a dialect. The dialect must be locatable, else a :class:`.NoSuchModuleError` is raised. The dialect must also include an existing :attr:`.DefaultDialect.construct_arguments` collection, indicating that it participates in the keyword-argument validation and default system, else :class:`.ArgumentError` is raised. If the dialect does not include this collection, then any keyword argument can be specified on behalf of this dialect already. All dialects packaged within SQLAlchemy include this collection, however for third party dialects, support may vary. :param argument_name: name of the parameter. :param default: default value of the parameter. .. versionadded:: 0.9.4 NzRDialect '%s' does have keyword-argument validation and defaults enabled configured)r _kw_registryr r)r<r argument_namedefaultconstruct_arg_dictionarys r argument_forDialectKWArgs.argument_for)s[P$1#=#=l#K # +##=?KL   .,. $ )7>%m4r"c[U5$)aA collection of keyword arguments specified as dialect-specific options to this construct. The arguments are present here in their original ``_`` format. Only arguments that were actually passed are included; unlike the :attr:`.DialectKWArgs.dialect_options` collection, which contains all options known by this dialect including defaults. The collection is also writable; keys are accepted of the form ``_`` where the value will be assembled into the list of options. .. versionadded:: 0.9.2 .. versionchanged:: 0.9.4 The :attr:`.DialectKWArgs.dialect_kwargs` collection is now writable. .. seealso:: :attr:`.DialectKWArgs.dialect_options` - nested dictionary form )rrs rdialect_kwargsDialectKWArgs.dialect_kwargs[s0t$$r"cUR$)z4A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.)rrs rrDialectKWArgs.kwargsus"""r"c[RUn[5nUcURR SS05 U$[ UR R5H'nXB;dM URR X$5 M) U$)N*)rrrrupdatereversedrf__mro__)rrrdr<s r_kw_reg_for_dialect_cls%DialectKWArgs._kw_reg_for_dialect_cls|s|#0#=#=l#K   # + KK  T{ +   6 672KK&&'?'DE8r"cj[R"[R"UR55$)aA collection of keyword arguments specified as dialect-specific options to this construct. This is a two-level nested registry, keyed to ```` and ````. For example, the ``postgresql_where`` argument would be locatable as:: arg = my_object.dialect_options['postgresql']['where'] .. versionadded:: 0.9.2 .. seealso:: :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form )r PopulateDictportable_instancemethodrrs rrDialectKWArgs.dialect_optionss+&   ( ()E)E F  r"c BU(dgUHn[R"SU5nU(d[SU-5eURSS5upEURUnSU;a1XV;a,[ R "SU<SU<SUR<35eXXe'M g![ Raj [R"S U<S U<35 [5=URU'nURRSS05 XURU'GMf=f) Nz ^(.+?)_(.+)$zGAdditional arguments should be named _, got '%s'rr rz Argument z is not accepted by dialect z on behalf of zCan't validate argument z,; can't locate any SQLAlchemy dialect named )rematch TypeErrorgrouprr rrfrrwarnrrrr)rrkmrarg_namerrs r_validate_dialect_kwargs&DialectKWArgs._validate_dialect_kwargss! A+A?ABC&'WWQ] "L C+/+?+? +M(77 @++lDNN< :@,6?(( 6 ,( :I9JJ$$\2Q ""C;/,2I) 6sB  A9DDr(N)r0r1r2r3r4r dp_dialect_options"_dialect_kwargs_traverse_internalsrIrrmemoized_propertyrpropertyrrrrrrrr6r(r"rrrs  -@@A*&/?/?b %%2##$$%89L    ,%Cr"rcf\rSrSrSrSr0r\S5rSr \S5r \S5r \S5r Sr g ) CompileStateiaProduces additional object state necessary for a statement to be compiled. the :class:`.CompileState` class is at the base of classes that assemble state for a particular statement object that is then used by the compiler. This process is essentially an extension of the process that the SQLCompiler.visit_XYZ() method takes, however there is an emphasis on converting raw user intent into more organized structures rather than producing string output. The top-level :class:`.CompileState` for the statement being executed is also accessible when the execution context works with invoking the statement and collecting results. The production of :class:`.CompileState` is specific to the compiler, such as within the :meth:`.SQLCompiler.visit_insert`, :meth:`.SQLCompiler.visit_select` etc. methods. These methods are also responsible for associating the :class:`.CompileState` with the :class:`.SQLCompiler` itself, if the statement is the "toplevel" statement, i.e. the outermost SQL statement that's actually being executed. There can be other :class:`.CompileState` objects that are not the toplevel, such as when a SELECT subquery or CTE-nested INSERT/UPDATE/DELETE is generated. .. versionadded:: 1.4  statementc ^UR(abURRSS5nURRXAR4S5nUcURSUR4nOURSUR4nXPLa U"X40UD6$UR"X40UD6$Ncompile_state_pluginr)_propagate_attrsreplugins_effective_plugin_targetcreate_for_statement)r<r compilerr* plugin_nameklasss rr!CompileState.create_for_statements  % %#4488& KKKOO@@A4E}  B BC KKI>>?E <y1b1 1--iHRH Hr"c Xlgr'r )rr rr*s rrBCompileState.__init__s"r"cURRSS5nU(a+X!R4nX0R;aURU$URSUR4$![a gf=fr)rrerrr)r<r rrs rget_plugin_classCompileState.get_plugin_classsz0044 "D   B BCCkk!{{3''  ;; 9+M+MNO O  sA++ A87A8cXURX!R4$![a gf=fr')rrr)r<r rs r_get_plugin_class_for_plugin)CompileState._get_plugin_class_for_plugins8 ;;@@A   s  ))c^^^UUU4SjnU$)Nc*>UTRTT4'U$r')r)cls_to_decorater<r visit_names rdecorate)CompileState.plugin_for..decorate"s5DCKKj1 2" "r"r()r<rr$r%s``` r plugin_forCompileState.plugin_for s #r"N)r0r1r2r3r4 __slots__rrIrrBrrr'r6r(r"rr r sh4IGII2#&r"r c\rSrSrSrSrSrg) Generativei)zQProvide a method-chaining pattern in conjunction with the @_generative decorator.cFURnURnURU5nU(aKURR 5R 5VVs0sHupEXA;dM XE_M snnUlU$URR 5UlU$s snnfr')_memoized_keysrfr>__dict__copyitems)rskipr<srvs rrXGenerative._generate-s""nn KK  "&!3!3!5!;!;!=!=!=AJ ++-AJ s  B+Br(Nr0r1r2r3r4rXr6r(r"rr+r+)s  r"r+c\rSrSrSrSrSrg)InPlaceGenerativei;zgProvide a method-chaining pattern in conjunction with the @_generative decorator that mutates in place.chURnUHnURRUS5 M! U$r')r-r.ro)rr1rs rrXInPlaceGenerative._generate?s0""A MM  a & r"r(Nr5r(r"rr7r7;s 5r"r7cV\rSrSrSrSr\R"5r\ Rr Sr g)HasCompileStateiFz=A class that has a :class:`.CompileState` associated with it.Nr() r0r1r2r3r4_compile_state_pluginr immutabledict _attributesr r_compile_state_factoryr6r(r"rr;r;Fs%G $$&K)>>r"r;c$\rSrSrSrSrSrSrg) _MetaOptionsiPz metaclass for the Options class.cp[[SU555Ul[R XX#5 g)Nc3f# UH'nURS5(aMUS;dM#Uv M) g7f)__)_cache_key_traversalN) startswith)r~rs rr(_MetaOptions.__init__..Us5A||D)66s 11 1)tuplesorted _cache_attrstyperB)r< classnamebasesdict_s rrB_MetaOptions.__init__Ss4    ce3r"cU"5n[U5RUR5(a5[SU<S[U5RUR5<35eURR U5 U$Nzr.rrrRrJrrSs rrVOptions.__add__rs ^^ # #DNN 3 4==) u: !2!2 3 3U..t/@/@AC  5! r"c[R"URUR5Hup#[X5[X5:wdM g gNFT)r zip_longestrJgetattr)rrTrrs r__eq__Options.__eq__sD$$T%6%68J8JKDAt75#44Lr"c^TRR<SSRU4SjTR55<S3$)N(, c3t># UH-nUTR;dMU<STRU<3v M/ g7f)=Nr.)r~rrs rr#Options.__repr__..s4*A %01dmmA./*s88))rfr0joinrJrs`r__repr__Options.__repr__s; NN # # II**   r"c[X5$r') issubclass)r<rs r isinstanceOptions.isinstances #%%r"c&X[X5U-0-$r')ra)rrhrs radd_to_elementOptions.add_to_elementsWT058999r"cUR$r'rirs r _state_dictOptions._state_dicts }}r"cUR$r')_state_dict_const)r<s rrwrxs$$$r"c TUR5nXRLaUR(av[UR5R UR5(aC[ SU<SU<S[UR5R UR5<35eX-$)Nzother element z is not empty, is not of type z+, and contains attributes not covered here )rwrfrJrrRr)r<rTrs r safe_mergeOptions.safe_merges      &""E&&'2233C3CDD**+66s7G7GH  wr"c8UR[U5RU55nURX5nU(aW0nUH"nSU-n X;aX8Xy'MX;dMXHXy'M$ Xg-n [R "5R X1U 05nX4$Xc4$)aprocess Options argument in terms of execution options. e.g.:: ( load_options, execution_options, ) = QueryContext.default_load_options.from_execution_options( "_sa_orm_load_options", { "populate_existing", "autoflush", "yield_per" }, execution_options, statement._execution_options, ) get back the Options and refresh "_sa_orm_load_options" in the exec options dict w/ the Options as well r)r|rrrerr= merge_with) r<rattrs exec_optionsstatement_exec_optionscheck_argnamesexisting_optionsresultargnamelocal new_optionss rfrom_execution_optionsOptions.from_execution_optionss<++   # #$: ; (++C5 F)g *$0$9FM6$:$CFM *+3K--/::K0L, ,$1 1r"r(N)r0r1r2r3r4rBrVrbrmrIrqrrtrwrr=rz classlevelr|rr6r(r"rrYrYls6!   &&::**,%%03232r"rYcX\rSrSr\S5r\R S5r\S5rSrg)CacheableOptionsic0[R"XU5$r')r_gen_cache_key)ranon_map bindparamss rrCacheableOptions._gen_cache_keys))$*EEr"c US4$rur()r<rrs rrrs Ryr"c.[R"U5$r')r_generate_cache_key_for_objectrs r_generate_cache_key$CacheableOptions._generate_cache_keys99$??r"r(N) r0r1r2r3rrrrr6r(r"rrrsFFF@@r"rc:\rSrSr\R rSrSrSr Sr g)ExecutableOptioniexecutable_optionFc URRUR5n[UR5UlU$)z/Create a shallow copy of this ExecutableOption.)rfr>rr.)rr*rTs rr+ExecutableOption._clone s/ NN " "4>> 2$--( r"r(N) r0r1r2r3r EMPTY_DICT _annotations__visit_name___is_has_cache_keyr+r6r(r"rrrs??L(Nr"rc\rSrSrSrSr\R"5rSr Sr Sr S\ R4S\R4S\R 4/rS rS rS rS rS rS r\S 5r\S 5r\S 5r\S 5r\S5r\S5rSr \RB"SSS9S5r"\RB"SSS9S5r#\\RB"SSS S9S55r$Sr%g) ExecutableizMark a :class:`_expression.ClauseElement` as supporting execution. :class:`.Executable` is a superclass for all "statement" types of objects, including :func:`select`, :func:`delete`, :func:`update`, :func:`insert`, :func:`text`. TNr( _with_options_with_context_optionsrFcUR$r')rrs rr#Executable._effective_plugin_target1s"""r"cNU=R[SU55- slg)aApply options to this statement. In the general sense, options are any kind of Python object that can be interpreted by the SQL compiler for the statement. These options can be consumed by specific dialects or specific kinds of compilers. The most commonly known kind of option are the ORM level options that apply "eager load" and other loading behaviors to an ORM query. However, options can theoretically be used for many other purposes. For background on specific kinds of options for specific kinds of statements, refer to the documentation for those option objects. .. versionchanged:: 1.4 - added :meth:`.Generative.options` to Core statement objects towards the goal of allowing unified Core / ORM querying capabilities. .. seealso:: :ref:`deferred_options` - refers to options specific to the usage of ORM queries :ref:`relationship_loader_options` - refers to options specific to the usage of ORM queries c3j# UH)n[R[RU5v M+ g7fr') coercionsexpectrExecutableOptionRole)r~rs rr%Executable.options..Ss-$    U77 = =s13N)rrHroptionss rrExecutable.options5s)< e$ $   r"cXlg)zlAssign the compile options to a new value. :param compile_options: appropriate CacheableOptions structure N_compile_options)rcompile_optionss r_set_compile_optionsExecutable._set_compile_optionsXs !0r"c.U=RU- slg)z*update the _compile_options with new keys.Nrrs r_update_compile_options"Executable._update_compile_optionsbs (r"c2U=RX44- slg)aAdd a context option to this statement. These are callable functions that will be given the CompileState object upon compilation. A second argument cache_args is required, which will be combined with the ``__code__`` identity of the function itself in order to produce a cache key. N)r)r callable_ cache_argss r_add_context_optionExecutable._add_context_optionhs "" '>&@@"r"c SU;a[R"S5eSU;a[R"S5eURRU5Ulg)aSet non-SQL options for the statement which take effect during execution. Execution options can be set on a per-statement or per :class:`_engine.Connection` basis. Additionally, the :class:`_engine.Engine` and ORM :class:`~.orm.query.Query` objects provide access to execution options which they in turn configure upon connections. The :meth:`execution_options` method is generative. A new instance of this statement is returned that contains the options:: statement = select(table.c.x, table.c.y) statement = statement.execution_options(autocommit=True) Note that only a subset of possible execution options can be applied to a statement - these include "autocommit" and "stream_results", but not "isolation_level" or "compiled_cache". See :meth:`_engine.Connection.execution_options` for a full list of possible options. .. seealso:: :meth:`_engine.Connection.execution_options` :meth:`_query.Query.execution_options` :meth:`.Executable.get_execution_options` isolation_levelz'isolation_level' execution option may only be specified on Connection.execution_options(), or per-engine using the isolation_level argument to create_engine().compiled_cachezm'compiled_cache' execution option may only be specified on Connection.execution_options(), not per statement.N)r r_execution_optionsrr)s rexecution_optionsExecutable.execution_optionsvscB  "##/  r !##H #'"9"9"?"?"Cr"cUR$)zGet the non-SQL options which will take effect during execution. .. versionadded:: 1.3 .. seealso:: :meth:`.Executable.execution_options` )rrs rget_execution_options Executable.get_execution_optionss&&&r"z:meth:`.Executable.execute`zAll statement execution in SQLAlchemy 2.0 is performed by the :meth:`_engine.Connection.execute` method of :class:`_engine.Connection`, or in the ORM by the :meth:`.Session.execute` method of :class:`.Session`.) alternativecURnUcE[USS5=(d URRnSU-n[R "U5eUR XU[R"55$)z.Compile and execute this :class:`.Executable`.N descriptionzThis %s is not directly bound to a Connection or Engine. Use the .execute() method of a Connection or Engine to execute this construct.) bindrarfr0r UnboundExecutionError_execute_clauseelementrr=)r multiparamsr$elabelrks rexecuteExecutable.executesz II 9mT2Mdnn6M6M -/45  ++C0 0'' vt'9'9';  r"z:meth:`.Executable.scalar`zScalar execution in SQLAlchemy 2.0 is performed by the :meth:`_engine.Connection.scalar` method of :class:`_engine.Connection`, or in the ORM by the :meth:`.Session.scalar` method of :class:`.Session`.cBUR"U0UD6R5$)z^Compile and execute this :class:`.Executable`, returning the result's scalar representation. )rscalar)rrr$s rrExecutable.scalars!||[3F3::< " to produce new symbols "_", where "index" is an incrementing integer corresponding to . Inlines the approach taken by :class:`sqlalchemy.util.PopulateDict` which is otherwise usually used for this type of operation. cURSS5up#URUS5nUS-X'US-[U5-nXPU'U$)N rr)rrestr)rridentderivedanonymous_counterrs r __missing__prefix_anon_map.__missing__sR99S!, HHWa0)A- # $5 66S  r"r(N)r0r1r2r3r4rr6r(r"rrrs  r"rc$\rSrSrSrSrSrSrg)SchemaEventTargeti zBase class for elements that are the targets of :class:`.DDLEvents` events. This includes :class:`.SchemaItem` as well as :class:`.SchemaType`. c g)z0Associate with this SchemaEvent's parent object.Nr(rparentr*s r _set_parentSchemaEventTarget._set_parentsr"c URRX5 UR"U40UD6 URRX5 gr')dispatchbefore_parent_attachrafter_parent_attachrs r_set_parent_with_dispatch+SchemaEventTarget._set_parent_with_dispatchs9 **48 &2& ))$7r"r(N)r0r1r2r3r4rrr6r(r"rrr s?8r"rc \rSrSrSrSS0rSrg) SchemaVisitoriz/Define the visiting for ``SchemaItem`` objects.schema_visitorTr(N)r0r1r2r3r4__traverse_options__r6r(r"rrrs9,d3r"rc\rSrSrSrSrS#SjrSr\S5r Sr S r S r S r S rS rSrSrSrSrSrS#SjrSrSrSrSrSrSrSrSrSrS#SjrSr Sr!Sr"S r#S$S!jr$S"r%g)%ColumnCollectioni!aoCollection of :class:`_expression.ColumnElement` instances, typically for :class:`_sql.FromClause` objects. The :class:`_sql.ColumnCollection` object is most commonly available as the :attr:`_schema.Table.c` or :attr:`_schema.Table.columns` collection on the :class:`_schema.Table` object, introduced at :ref:`metadata_tables_and_columns`. The :class:`_expression.ColumnCollection` has both mapping- and sequence- like behaviors. A :class:`_expression.ColumnCollection` usually stores :class:`_schema.Column` objects, which are then accessible both via mapping style access as well as attribute access style. To access :class:`_schema.Column` objects using ordinary attribute-style access, specify the name like any other object attribute, such as below a column named ``employee_name`` is accessed:: >>> employee_table.c.employee_name To access columns that have names with special characters or spaces, index-style access is used, such as below which illustrates a column named ``employee ' payment`` is accessed:: >>> employee_table.c["employee ' payment"] As the :class:`_sql.ColumnCollection` object provides a Python dictionary interface, common dictionary method names like :meth:`_sql.ColumnCollection.keys`, :meth:`_sql.ColumnCollection.values`, and :meth:`_sql.ColumnCollection.items` are available, which means that database columns that are keyed under these names also need to use indexed access:: >>> employee_table.c["values"] The name for which a :class:`_schema.Column` would be present is normally that of the :paramref:`_schema.Column.key` parameter. In some contexts, such as a :class:`_sql.Select` object that uses a label style set using the :meth:`_sql.Select.set_label_style` method, a column of a certain key may instead be represented under a particular label name such as ``tablename_columnname``:: >>> from sqlalchemy import select, column, table >>> from sqlalchemy import LABEL_STYLE_TABLENAME_PLUS_COL >>> t = table("t", column("c")) >>> stmt = select(t).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL) >>> subq = stmt.subquery() >>> subq.c.t_c :class:`.ColumnCollection` also indexes the columns in order and allows them to be accessible by their integer position:: >>> cc[0] Column('x', Integer(), table=None) >>> cc[1] Column('y', Integer(), table=None) .. versionadded:: 1.4 :class:`_expression.ColumnCollection` allows integer-based index access to the collection. Iterating the collection yields the column expressions in order:: >>> list(cc) [Column('x', Integer(), table=None), Column('y', Integer(), table=None)] The base :class:`_expression.ColumnCollection` object can store duplicates, which can mean either two columns with the same key, in which case the column returned by key access is **arbitrary**:: >>> x1, x2 = Column('x', Integer), Column('x', Integer) >>> cc = ColumnCollection(columns=[(x1.name, x1), (x2.name, x2)]) >>> list(cc) [Column('x', Integer(), table=None), Column('x', Integer(), table=None)] >>> cc['x'] is x1 False >>> cc['x'] is x2 True Or it can also mean the same column multiple times. These cases are supported as :class:`_expression.ColumnCollection` is used to represent the columns in a SELECT statement which may include duplicates. A special subclass :class:`.DedupeColumnCollection` exists which instead maintains SQLAlchemy's older behavior of not allowing duplicates; this collection is used for schema level objects like :class:`_schema.Table` and :class:`.PrimaryKeyConstraint` where this deduping is helpful. The :class:`.DedupeColumnCollection` class also has additional mutation methods as the schema constructs have more use cases that require removal and replacement of columns. .. versionchanged:: 1.4 :class:`_expression.ColumnCollection` now stores duplicate column keys as well as the same column in multiple positions. The :class:`.DedupeColumnCollection` class is added to maintain the former behavior in those cases where deduplication as well as additional replace/remove operations are needed. ) _collection_index_colsetNc[RUS[55 [RUS05 [RUS/5 U(aURU5 gg)Nrrr)rA __setattr__r_initial_populate)rcolumnss rrBColumnCollection.__init__sP4CE242.43   " "7 + r"c&URU5 gr'_populate_separate_keysriter_s rr "ColumnCollection._initial_populates $$U+r"cPURVVs/sHupUPM snn$s snnfr'rrrcols r _all_columnsColumnCollection._all_columnss$$($4$45$4$4555"cPURVVs/sHupUPM snn$s snnf)zIReturn a sequence of string key names for all columns in this collection.rrs rkeysColumnCollection.keyss&#'"2"23"2hq"2333rcPURVVs/sHupUPM snn$s snnf)zvReturn a sequence of :class:`_sql.ColumnClause` or :class:`_schema.Column` objects for all columns in this collection.rrs rrColumnCollection.valuess&%)$4$45$4$4555rc,[UR5$)zReturn a sequence of (key, column) tuples for all columns in this collection each consisting of a string key name and a :class:`_sql.ColumnClause` or :class:`_schema.Column` object. )listrrs rr0ColumnCollection.itemssD$$%%r"c,[UR5$r')boolrrs r__bool__ColumnCollection.__bool__sD$$%%r"c,[UR5$r')rrrs rrColumnCollection.__len__s4##$$r"cb[URVVs/sHupUPM snn5$s snnfr')rrrs rrColumnCollection.__iter__s)t'7'78'7VQS'78998s+ cURU$![aHn[U[R5(a#[R "[ U5US9 SnAgeSnAff=fr)rrrqr int_typesr IndexErrorrrrs rrColumnCollection.__getitem__sL ;;s# # #t~~.. JsOSA  s A#=AAA#cURU$![a(n[R"[ U5US9 SnAgSnAff=fr)rrrrAttributeErrorr,s r __getattr__ColumnCollection.__getattr__s< B;;s# # B KKs+S A Bs A>AcXR;a6[U[R5(d[R "S5egg)Nz'__contains__ requires a string argumentFT)rrqr string_typesr rrs r __contains__ColumnCollection.__contains__s= kk !c4#4#455''=r"cN[R"X5H up#X#LdM g g)z\Compare this :class:`_expression.ColumnCollection` to another based on the names of the keysFT)rr`)rrTlrs rcompareColumnCollection.compares($$T1DAz2r"c$URU5$r')r9rrTs rrbColumnCollection.__eq__s||E""r"cBXR;aURU$U$)zGet a :class:`_sql.ColumnClause` or :class:`_schema.Column` object based on a string key name from this :class:`_expression.ColumnCollection`.)r)rrrs rreColumnCollection.gets" ++ ;;s# #Nr"cjURR<SSRSU55<S3$)Nrerfc38# UHn[U5v M g7fr')r)r~rTs rr+ColumnCollection.__str__..s+dc!ffdsrk)rfr0rlrs r__str__ColumnCollection.__str__s+ NN # # II+d+ +  r"c[5er'rrs rrColumnCollection.__setitem__ !##r"c[5er'rrs rrColumnCollection.__delitem__rGr"c[5er'r)rrrEs rrColumnCollection.__setattr__rGr"c[5e)zIDictionary clear() is not implemented for :class:`_sql.ColumnCollection`.rrs rclearColumnCollection.clear "##r"c[5e)zJDictionary remove() is not implemented for :class:`_sql.ColumnCollection`.r)rcolumns rremoveColumnCollection.removerOr"c[5e)zJDictionary update() is not implemented for :class:`_sql.ColumnCollection`.rrs rrColumnCollection.updaterOr"c[U5nX RSS&URRSUR55 URRS[ UR555 URR[ UR5VVs0sHup4X4_M snn5 gs snnf)*populate from an iterator of (key, column)Nc3*# UH upUv M g7fr'r(r~rrTs rr;ColumnCollection._populate_separate_keys..s;*:$!A*:c32# UH unup#X4v M g7fr'r(r~idxrrTs rrrZ (CfqSH(C)rrrrr enumerater)rrcolsrrs rr(ColumnCollection._populate_separate_keys sE{" ;$*:*:;;  (1$2B2B(C   $:J:J1KL1KvqAF1KLMLs(B? cUc URn[UR5nURRX!45 URR U5 XR U'X R ;aXR U'gg)aAdd a column to this :class:`_sql.ColumnCollection`. .. note:: This method is **not normally used by user-facing code**, as the :class:`_sql.ColumnCollection` is usually part of an existing object such as a :class:`_schema.Table`. To add a :class:`_schema.Column` to an existing :class:`_schema.Table` object, use the :meth:`_schema.Table.append_column` method. N)rrrappendraddr)rrQrr7s rrfColumnCollection.addsp ;**C   !  .   A kk !%KK  "r"c4URURS.$)Nrrrirs r __getstate__ColumnCollection.__getstate__,s#//4;;GGr"c [RUSUS5 [RUSUS5 [RUSURVVs1sHup#UiM snn5 gs snnf)Nrrr)rArr)rstaterrs r __setstate__ColumnCollection.__setstate__/s`45?;4m0DE )0@0@A0@fac0@A AsA,cXR;a6[U[R5(a[R "S5egg)z3Checks if a column object exists in this collectionzZcontains_column cannot be used with string arguments. Use ``col_name in table.c`` instead.FT)rrqrr3r rrrs rcontains_column ColumnCollection.contains_column6s? ll "#t0011'';r"c[U5$)zBReturn an "immutable" form of this :class:`_sql.ColumnCollection`.)ImmutableColumnCollectionrs r as_immutableColumnCollection.as_immutableBs)..r"c SnXR;aU$SupEURnURVVs/sHupxUPM n nnU GHrn[[ UR55n UR U 5n U (dM<U(aU"X5(dMRUcXpTMY[ U 5[ U5:aXpTMuX:XdM|[R"[RUR5V s/sH7n U RU5(dMU RRSS5PM9 sn 5n [R"[RUR5V s/sH7n U RU5(dMU RRSS5PM9 sn 5nX:dGMpXpTGMu U$s snnfs sn fs sn f)a*Given a :class:`_expression.ColumnElement`, return the exported :class:`_expression.ColumnElement` object from this :class:`_expression.ColumnCollection` which corresponds to that original :class:`_expression.ColumnElement` via a common ancestor column. :param column: the target :class:`_expression.ColumnElement` to be matched. :param require_embedded: only return corresponding columns for the given :class:`_expression.ColumnElement`, if the given :class:`_expression.ColumnElement` is actually present within a sub-element of this :class:`_expression.Selectable`. Normally the column will match if it merely shares a common ancestor with one of the exported columns of this :class:`_expression.Selectable`. .. seealso:: :meth:`_expression.Selectable.corresponding_column` - invokes this method against the collection returned by :attr:`_expression.Selectable.exported_columns`. .. versionchanged:: 1.4 the implementation for ``corresponding_column`` was moved onto the :class:`_expression.ColumnCollection` itself. cURU5H.n[[U/55RU5(aM. g gr_)rRrrxr|)expanded_proxy_set target_setts rembedded7ColumnCollection.corresponding_column..embeddedhsD**+=>>1#./<<&! ? r")NNweightr)rrDrrrxr|rrreducerprf_uncached_proxy_listshares_lineagerre)rrQrequire_embeddedr}r intersectr{rrTrbrzisc col_distance c_distances rcorresponding_column%ColumnCollection.corresponding_columnHs@  \\ !M#%% $ 0 01 0fq 01A!$^AKK%@!A ''(:;Aq$.;;;&'Vc)n,&'^$(;; '*&>&>&@&@!008=BOO//!<&@$L"& '(&<&<&>&>!008=BOO//!<&>"J"0)*Yab e2DsG4G  G *G  G r(r')F)&r0r1r2r3r4r)rBr r rrrr0r#rrrr0r4r9rbrerCrrrrMrRr__hash__rrfrjrnrrrvrr6r(r"rrr!sjX3I,,664 6 &&%:B # $$$$ $ $ HN&,H  / _r"rc:\rSrSrSrS SjrSrSrSrSr S r g) DedupeColumnCollectioniaYA :class:`_expression.ColumnCollection` that maintains deduplicating behavior. This is useful by schema level objects such as :class:`_schema.Table` and :class:`.PrimaryKeyConstraint`. The collection includes more sophisticated mutator methods as well to suit schema objects which require mutable column collections. .. versionadded:: 1.4 NcUb&URU:wa[R"S5eURnUc[R"S5eX R;aFURUnX1LagUR U5 [ R RUS5 g[UR5nURRX!45 URRU5 XRU'XRU'g)NKDedupeColumnCollection requires columns be under the same key as their .keyz-Can't add unnamed column to column collectionrD) rr rrreplacerrresetrrrerrf)rrQrexistingr7s rrfDedupeColumnCollection.adds ?vzzS0##- jj ;##?  ++ {{3'H! LL  " " ( ( =D$$%A    # #SM 2 LL  V $#KKN%KK r"c[U5n/nUHupEURU:wa[R"S5eURUR ;a-URUR:waUR U5 MrURUR ;aUR U5 MXPR U'URR XE45 M URRSUR55 UR RS[UR555 UHnURU5 M g)rWrc3*# UH upUv M g7fr'r(rYs rrADedupeColumnCollection._populate_separate_keys..s=,<&1A,""3'DKK'""3'!$ A  ''1 =D,<,<==  (1$2B2B(C  C LL r"c4URSU55 g)Nc3<# UHoRU4v M g7fr')r)r~rs rr0DedupeColumnCollection.extend..s$Euggs^usr rs rextendDedupeColumnCollection.extends $$$Eu$EEr"c XR;a[SU-5eURUR URR U5 UR VVs/sHup#X1LdM X#4PM snnUR SS&URR [UR 5VVVs0sH unup%XE_M snnn5 UR[UR 5 gs snnfs snnnf)Nz8Can't remove column %r; column is not in this collection) rrrrrRrrrar)rrQrrTr^rs rrRDedupeColumnCollection.removes  %J  KK # F#!%!1!1 !1vQ_FQF!1  +4T5E5E+F G+F-#xSX+F G  KKD,,- .  Hs C.-C.3C4 c :[5nURUR;a^URUR:waDURURnURUR:XaUR U5 URUR;a(UR URUR5 /nSnUR HFupgXr;a*U(d!SnUR URU45 M2M4UR Xg45 MH U(aURRU5 U(dUR URU45 URR U5 X@R SS&URR5 URR[UR 5VVVs0sH unupgX_M snnn5 URRUR 5 gs snnnf)aadd the given column to this collection, removing unaliased versions of this column as well as existing columns with the same key. e.g.:: t = Table('sometable', metadata, Column('col1', Integer)) t.columns.replace(Column('col1', Integer, key='columnone')) will remove the original 'col1' from the collection, and add the new column under the name 'columnname'. Used by schema.Column to override columns during table reflection. FTN) rrhrrrfrrerdifference_updaterMrra) rrQ remove_colrTnew_colsreplacedrrr^s rrDedupeColumnCollection.replaces"U ;;$++ %&** *CKK ,EzzUYY&u% :: $ NN4;;vzz2 3&&FA #HOOVZZ$89 ) '  LL * *: 6 OOVZZ0 1  &  +4T5E5E+F G+F-#xSX+F G  4++, HsH r(r') r0r1r2r3r4rfrrrRrr6r(r"rrrs"  &D2F/"2-r"rc^\rSrSrSrSrSrSr\RR=r =r r Srg)rui;_parentc[RUSU5 [RUSUR5 [RUSUR5 [RUSUR5 g)Nrrrr)rArrrr)r collections rrB"ImmutableColumnCollection.__init__>s\4J74J,>,>?4:+<+<=4 0F0FGr"cSUR0$Nrrrs rrj&ImmutableColumnCollection.__getstate__Ds4<<((r"c0USnURU5 gr)rB)rrmrs rrn&ImmutableColumnCollection.__setstate__Gsy! fr"r(N)r0r1r2r3r)rBrjrnrImmutableContainer _immutablerfrrRr6r(r"rruru;s4IH )!33>>>C>&6r"ruc2\rSrSrSrSrSrSrSrSr g) ColumnSetiNc X;$r'r(rqs rrrColumnSet.contains_columnOs {r"c8UHnURU5 M gr')rf)rrbrs rrColumnSet.extendRsC HHSMr"c0[U5[U5-$r')rr<s rrVColumnSet.__add__VsDzDK''r"c/nUH7nUH.nURU5(dMURX4:H5 M0 M9 [R"U6$r')rrerOand_)rrTr7rTrs rrbColumnSet.__eq__YsK A##E**HHQZ(}}a  r"c8[[SU555$)Nc3$# UHov M g7fr'r()r~r[s rr%ColumnSet.__hash__..bs*T!Ts)hashrHrs rrColumnSet.__hash__asE*T**++r"r(N) r0r1r2r3rrrrVrbrr6r(r"rrrNs(!,r"rc [R"S5 URnU(dbURRn[ US[ USS55nU(a U<SU<3nOSU-nUcSU-n[ R"U5eU$)Nz|The ``bind`` argument for schema methods that invoke SQL against an engine or connection will be required in SQLAlchemy 2.0.fullnamerhz object z %s objectzm%s is not bound to an Engine or Connection. Execution can not proceed without a database to execute against.)rwarn_deprecated_20rrfr0rar r) schemaitemrkrrhritems r_bind_or_errorres N ??D ##,,  GJ$E  %)51D%D ;!"  '',, Kr"cUR$![a@ [R"U5H$n[ US5(dMURs s$ ef=f)zReturn the nearest .entity_namespace for the given entity. If not immediately available, does an iterate to find a sub-element that has one, if any. entity_namespace)rr/riteratehasattr)entityrs r_entity_namespacersV&&& $$V,Dt/00,,,-  s 2AAAc [U5nU[La [X1U5$[X15$![a<n[R "[ R"SU<SU<S35US9 SnAgSnAff=f)zReturn an entry from an entity_namespace. Raises :class:`_exc.InvalidRequestError` rather than attribute error on not found. zEntity namespace for "z" has no property ""rN)rrrar/rrr rg)rrrnsrs r_entity_namespace_keyrsj  v & & 2G, ,2# #    # #3     s- - A32A..A3r')Cr4rKrprrr traversalsrrrr r r r rrrrrOtype_apisymbolrrrArr8rNrUr\rsr+rxrrcollections_abcMutableMappingrrpreload_modulerrr r+r7r;rKrAwith_metaclassrYrr StatementRolerrrrrrrrruordered_column_setrrrrr(r"rrs  #(+#/'   ;;12 X   $ 0 ,: ? 9 d**999 x$d**99$@*+1,1lCFlC^_6_D$ ?j?48G2d!!,/G2T @w @ ' `$$j`Fd*88"4M4 FvFR N--N-b? 7 79I?&,'',.4"06 r"