-h SrSSKrSSKrSSKJr SSKJr SSKJr SSKJr SSKJ r S S K J r S S K J r S S K Jr S S K Jr S S K J r S SKJr S SKJr S SKJr S SKJr S SKJr \ R0"S5rSrSrS rSrSrSrSr "SS\5r!"SS\!5r""SS\#5r$"SS\$5r%"S S!\%5r&\&"5r'"S"S#\%5r(\("5r)"S$S%\$5r*\*"5r+"S&S'\*5r,"S(S)\*5r-"S*S+\5r."S,S-\.5r/\."5r0\/"5r1"S.S/\#5r2"S0S1\2\5r3"S2S3\35r4\4r5"S4S5\55r6"S6S7\55r7"S8S9\ 5r8"S:S;\55r9g) F8FF &F cURR(dU$URRnURnX#LaU$URR UR5n[ UR5UlURn[UR5HupgXVnXRU'M URUl URUl UR(aeSUlSUlUR UlURUlUR"UlU$![a Mf=f)a3When using a cached Compiled construct that has a _result_map, for a new statement that used the cached Compiled, we need to ensure the keymap has the Column objects from our new statement as keys. So here we rewrite keymap with new entries for the new columns as matched to those of the cached statement. N)compiled_result_columns statementinvoked_statementr7r8dictrrr9_all_selected_columnsKeyErrorrrr r!rr") r&contextcompiled_statementrMmdkeymap_by_positionr@newr=s r(_adapt_to_context&CursorResultMetaData._adapt_to_contextms'//K$--77#55  2K^^ # #DNN 3$,,' !>>!"3"I"IJHC &(- #& 3K!//))$$$$!%::*.*K*K'!11   s,D:: EEc URnURnSUlSUlURUlSUlUR (aUR unnnnn [U5n O S=n=n=n =n=pURUUUU UUUU 5n 0Ul U V s/sH o[PM sn Ul UR(a U V s0sH n U [U _M sn Ul[U V s/sHn U [ U 4PM sn 5n U (Ga[U 5U :wGa,0n[#5nU Hn U [$4U [&=(d S-HunUR(d/[)U[*R,5(aUR/5nU [0nUR3UU5U:wdMdUR5U5 Mw M URR7U V Vs/sH0n U [&(dMU [&HnUU;dM UU 4PM M2 snn 5 U R7UVs0sH nUSSSU4_M sn5 OQURR7U V Vs/sH(n U [&(dMU [&HnUU 4PM M* snn 5 URR7U 5 U (dlUR8(aZURR7U V s/sH2n U [:(dMU [:URU [ 4PM4 sn 5 gggs sn fs sn fs sn fs snn fs snfs snn fs sn f)NFr2)rQdialectr r!rr"result_column_structlen_merge_cursor_descriptionr MD_PROCESSORrrJMD_RESULT_MAP_INDEXrrNr6setMD_RENDERED_NAMEr. isinstancer string_typeslowerr5 setdefaultaddr:_translate_colnameMD_UNTRANSLATED)r&parentcursor_descriptionrQrYresult_columnscols_are_orderedtextual_orderedad_hoc_textualloose_column_name_matching num_ctx_colsrawmetadata_entryby_key index_by_keydupesr'r@obj_elems r(__init__CursorResultMetaData.__init__s..// #' %44$  ' ',,   *~.L@E  EN E  E E   E +,,        &   @C ?B^< (s    '*1&)N23^C&)1D - '* &)N .?&)   6{l* " &)N ./? @B&z28b  $22z!2!288#&))+C,X6(223<C!IIcN '*  ##/2.1N)*53)7z(BH#50 3>2)C3.1 UKUcsT4S$99UKL  ##/2.1N)*53)7z(BH">2)C3.1 F# : : LL   +.  +.%o6 &7 ^M%BC+.  !;|o 1 ZL sBL0 L50L:)L? ?L?  L? 7M*M M -M#Mc BURRn U(aU(aU(dU[U5:XaUV s/sHoSPM sn UlSUl[ U5V V s/sHeupU U U [ U (dU [R5OU [U [URU [U [X+S5S4PMg sn n $U(dU(a)[U5U:XaSUlURXU5n O;U(aSUlURUUUU5n OSUlURX5n U V VVVVVVs/sH%un nnnnnnU UUUUURUUU5U4PM' snnnnnnn $s sn fs sn n fs snnnnnnn f)a Merge a cursor.description with compiled result column information. There are at least four separate strategies used here, selected depending on the type of SQL construct used to start with. The most common case is that of the compiled SQL expression construct, which generated the column names present in the raw SQL string and which has the identical number of columns as were reported by cursor.description. In this case, we assume a 1-1 positional mapping between the entries in cursor.description and the compiled object. This is also the most performant case as we disregard extracting / decoding the column names present in cursor.description since we already have the desired name we generated in the compiled SQL construct. The next common case is that of the completely raw string SQL, such as passed to connection.execute(). In this case we have no compiled construct to work with, so we extract and decode the names from cursor.description and index those as the primary result row target keys. The remaining fairly common case is that of the textual SQL that includes at least partial column information; this is when we use a :class:`_expression.TextualSelect` construct. This construct may have unordered or ordered column information. In the ordered case, we merge the cursor.description and the compiled construct's information positionally, and warn if there are additional description names present, however we still decode the names in cursor.description as we don't have a guarantee that the names in the columns match on these. In the unordered case, we match names in cursor.description to that of the compiled construct based on name matching. In both of these cases, the cursor.description names and the column expression objects and names are indexed as result row target keys. The final case is much less common, where we have a compiled non-textual SQL expression construct, but the number of columns in cursor.description doesn't match what's in the compiled construct. We make the guess here that there might be textual column expressions in the compiled construct that themselves include a comma in them causing them to split. We do the same name-matching as with textual non-ordered columns. The name-matched system of merging is the same as that used by SQLAlchemy for all cases up through te 0.9 series. Positional matching for compiled SQL expressions was introduced in 1.0 as a major performance feature, and positional matching for textual :class:`_expression.TextualSelect` objects in 1.1. As name matching is no longer a common case, it was acceptable to factor it into smaller generator- oriented methods that are easier to understand, but incur slightly more performance overhead. rTrNF)rYrr[rr"r9rrrcrget_result_processorr_merge_textual_cols_by_position_merge_cols_by_name_merge_cols_by_none)r&rQrirjrorkrlrmrnrelemr@ rmap_entry raw_iteratorridxcursor_colname mapped_typecoltypeobj untranslateds r(r\.CursorResultMetaData._merge_cursor_description)sD!77  #$6 77.<=ndq'n=DJ $(D "(1'@! (AOCz*)w'--/#G,/000"7+"#34*/2 (A! .3'9#:l#J'+$#CC   (-$#77&".   (-$#77  0")("" #""00#^W! &") u>fsF *A,F,Fc## URnURnURnUR(a UROSnUR (a UR OSnSn/Ul[U5HvupU Sn U Sn U(aU"U 5n U(a U"U 5upU(aU"U 5n URRU 5 U(dU R5n XX4v Mx g7f)zExtract column names and data types from a cursor.description. Applies unicode decoding, column translation, "normalization", and case sensitivity rules to the names based on the dialect. Nrr) rYrrfdescription_encoding_description_decoderrequires_name_normalizenormalize_namerr9appendrc) r&rQrirYrtranslate_colnamedescription_decoderrrr@r=colnamers r(_colnames_from_description/CursorResultMetaData._colnames_from_descriptions// //#66++  ( (  '.&E&EG " "4   !"45HC!fG!fG"-g6 (9'(B%(1 JJ  g &!!--/ 5 5#6sC2C4c## U(a [U5OSnU[U5:a$[R"SU[U54-5 [5nUR X5H{unnnn Xd:aRX6n U [ n Un U [ n U SU;a[R"SU S-5eURU S5 O[Rn Sn Sn XlX}XU4v M} g7f)NzVNumber of columns in textual SQL (%d) is smaller than number of columns requested (%d)rz8Duplicate column expression requested in textual SQL: %r) r[r warnr_rrrr InvalidRequestErrorrer NULLTYPE)r&rQrirjroseenr@rrrctx_recrrrs r(rz4CursorResultMetaData._merge_textual_cols_by_positions/=s>*$ #01 1 II@%7!89:  u  , ,W I     !(-j)%g. q6T>11-/21v6Q &// W7M M!JsC#C%c# # URnURnURX6U5nURX5H'unn n n Xyn U Sn U SnU SnUUU UU U U 4v M) g![a [ R nSn SnN0f=f7f)Nrr r)rYr_create_description_match_maprrPr r)r&rQrirjrnrYr match_mapr@rrrrrrresult_columns_idxs r(r{(CursorResultMetaData._merge_cols_by_names// //66 ,F  , ,W I      0#, aj%aj %,QZ"" J *&// %)" *s*ABA* B*B B B  Bc n0n[U5HupVU[nU(dUR5nXt;aXGuppXU[-X4XG'OU[U[U[ U4XG'U(dMhU[H.n UR U U[U[U[ U45 M0 M U$)zwhen matching cursor.description to a set of names that are present in a Compiled object, as is the case with TextualSelect, get all the names we expect might match those in cursor.description. )r9rrcrrrrd) clsrjrrndrr}r'e_namee_obje_typee_ridxr_keys r(r2CursorResultMetaData._create_description_match_map7s #N3JD'(C!iikx 12-vj)9!96Gw-j)94=$O)) "*-ELLgZ(8$w-N.+46r+c#x# URX5H!unnnnUSU[RUSU4v M# g7fr$)rr r)r&rQrir@rrrs r(r|(CursorResultMetaData._merge_cols_by_noneasS  , ,W I     !! Js8:cU(aA[R"[R"S[R"U5-5US9 gg)N.Could not locate column in row for column '%s'replace_context)r raise_r NoSuchColumnErrorstring_or_unprintable)r&r'errraiseerrs r( _key_fallback"CursorResultMetaData._key_fallbackrs?  KK%%D0056!$  r+cB[R"SU[-5e)NzA99A>cUVs/sHo RUSPM sn$s snf![a-n[RXRSU5 SnAgSnAff=fr)rrPrrargs)r&r;r'rs r(_indexes_for_keys&CursorResultMetaData._indexes_for_keyssY E489DSLL%a(D9 99 E . .tWWQZ D D Es )$)) A #AA c#F# UH]n[URR;aURUnURUnWSnUcURU5 Uv M_ g![ a-n[ RXRSU5 SnANTSnAff=f7fr) rr7__mro__rrrPrrrr)r&r;r'r=rrCs r(r4'CursorResultMetaData._metadata_for_keyssCcmm+++jjo Ill3' FE}55c:I  I$224RHH Is.3B!A'"B!' B1#BB!BB!c XURR5VVs0sHOup[U[R[R -5(dM7X[ U[[U4_MQ snnURURURURS.$s snnf)N)rrrr!r ) ritemsrar rb int_typesr5r^ _UNPICKLEDrrr!r )r&r'r=s r( __getstate__!CursorResultMetaData.__getstate__s!% 2 2 4 4HCc4#4#4t~~#EFP(mS)<%=z3OO 4 ZZ"11#'#;#; --  s 6B&B&c[[US55Vs/sHnSPM snUlUSUlURR 5Vs0sH o3[ U_M snUlUSUlUSUlUS(a"USUl [UR6Ul gS=Ul Ul gs snfs snf)Nrrrr!) ranger[rrvaluesr^rrrr!rr )r&state_r=s r( __setstate__!CursorResultMetaData.__setstate__s*/E'N0C*DE*DQD*DEY' 6:\\5H5H5J- 5Jc# $c )5J- )7^ #$45 & '',-B'CD $ +T-E-E FD ;? ?D $t'8F- s B>C)rrrrr"r!r rN)TFT)__name__ __module__ __qualname____firstlineno____doc__ __slots__ returns_rowsr)r/rGrVrvr\rrzr{ classmethodrr|rrrrr4rr__static_attributes__r2r+r(rr-s, IL# #J,\L\Yv(6T!NF$L#( ''R"  &E$  @r+rc4\rSrSrSrSrSSjrSrSrSr g) LegacyCursorResultMetaDatair2c|UnX0R;a[R"S5 gURUSS5SL$)NzUsing the 'in' operator to test for string or column keys, or integer indexes, in a :class:`.Row` object is deprecated and will be removed in a future release. Use the `Row._fields` or `Row._mapping` attribute, i.e. 'key in row._fields'TF)rr warn_deprecated_20r)r&valuerowr's r( _contains$LegacyCursorResultMetaData._containssC ,,   # #' %%c47tC Cr+cURnSn[U[R5(a4UR UR (aUOUR 55nGO[U[R5(GaUR(avUR (a UROURR 5U;a;UUR (a UROURR 5nO[US5(auUR (a UROURR 5U;a:UUR (a UROURR 5nUb=U[S[4;a*U[HnURU5(dM O SnUb;U[[La[R"SSS9 O[R"SSS9 UcJU(aB[R "["R$"S[R&"U5-5US9 U$gXTU'U$)NnamezRetrieving row values using Column objects from a row that was unpickled is deprecated; adequate state cannot be pickled for this to be efficient. This usage will raise KeyError in a future release.z1.4)versionzRetrieving row values using Column objects with only matching names as keys is deprecated, and will raise KeyError in a future release; only Column objects that are explicitly part of the statement object should be used.rr)rrar rbgetrrcr ColumnElement _tq_labelhasattrrr.r_compare_name_for_resultwarn_deprecatedrr rr)r&r'rrmap_resultrs r(r(LegacyCursorResultMetaData._key_fallbacks|| c4,, - -XXT%8%8cciikJF Z55 6 6 **MM,,. **MM,,. V$$!%!4!4SXX#((..:J $ 3 3CHH9I!fZ&8A'"*-C33C88."F!*%3((N!& ((1 !&  > ))H44S9:%(  I r+c.[R"SSS9 g)NzUsing non-integer/slice indices on Row is deprecated and will be removed in version 2.0; please use row._mapping[], or the mappings() accessor on the Result object.r) stacklevelr rr%s r(_warn_for_nonint+LegacyCursorResultMetaData._warn_for_nonint.s  <  r+cLXR;agURUSS5SL$)NTF)rrr%s r(r)#LegacyCursorResultMetaData._has_key6s) ,, %%c47tC Cr+Nr) rrrrrrrrr)rr2r+r(rrsI DKZ Dr+rcR\rSrSrSrSrSrSrSrSr S Sjr S S jr S r S r Srg)ResultFetchStrategyi=zIDefine a fetching strategy for a result object. .. versionadded:: 1.4 r2Nc[5er$NotImplementedErrorr&r dbapi_cursors r( soft_closeResultFetchStrategy.soft_closeI !##r+c[5er$rrs r( hard_closeResultFetchStrategy.hard_closeLrr+cgr$r2r&rrnums r( yield_perResultFetchStrategy.yield_perOsr+c[5er$rr&rrrs r(fetchoneResultFetchStrategy.fetchoneRrr+c[5er$rr&rrsizes r( fetchmanyResultFetchStrategy.fetchmanyUrr+c[5er$r)r&rs r(fetchallResultFetchStrategy.fetchallXrr+cUer$r2r&rrrs r(handle_exception$ResultFetchStrategy.handle_exception[s r+Fr$)rrrrrralternate_cursor_descriptionrrrr rrrrr2r+r(rr=s7I#' $$$$$r+rcL\rSrSrSrSrSrSrS SjrS Sjr S r S S jr Sr g) NoCursorFetchStrategyi_zCursor strategy for a result that has no open cursor. There are two varieties of this strategy, one for DQL and one for DML (and also DDL), each of which represent a result that had a cursor but no longer has one. r2cgr$r2rs r(r NoCursorFetchStrategy.soft_closej r+cgr$r2rs r(r NoCursorFetchStrategy.hard_closemrr+c&URUS5$r$ _non_resultr s r(r NoCursorFetchStrategy.fetchoneps--r+Nc&URU/5$r$r"r s r(rNoCursorFetchStrategy.fetchmanys++r+c&URU/5$r$r"rs r(rNoCursorFetchStrategy.fetchallvr'r+c[5er$rr&rdefaultrs r(r#!NoCursorFetchStrategy._non_resultyrr+rr$) rrrrrrrrr rrr#rr2r+r(rr_s,I  .,,$r+rc&\rSrSrSrSrSSjrSrg)NoCursorDQLFetchStrategyi}aCursor strategy for a DQL result that has no open cursor. This is a result set that can return rows, i.e. for a SELECT, or for an INSERT, UPDATE, DELETE that includes RETURNING. However it is in the state where the cursor is closed and no rows remain available. The owning result object may or may not be "hard closed", which determines if the fetch methods send empty results or raise for closed result. r2Nc|UR(a*[R"[R"S5US9 gU$)NzThis result object is closed.r)closedr rr ResourceClosedErrorr+s r(r#$NoCursorDQLFetchStrategy._non_results. == KK''(GH #  Nr+r$rrrrrrr#rr2r+r(r/r/}sIr+r/c&\rSrSrSrSrSSjrSrg)NoCursorDMLFetchStrategyizCursor strategy for a DML result that has no open cursor. This is a result set that does not return rows, i.e. for an INSERT, UPDATE, DELETE that does not include RETURNING. r2NctURR(aeURRU5 gr$) _metadatar_we_dont_return_rowsr+s r(r#$NoCursorDMLFetchStrategy._non_results+##0000--c2r+r$r4r2r+r(r6r6sI3r+r6cN\rSrSrSrSrSrSrSrSr S Sjr S S jr S r Sr g )CursorFetchStrategyizCall fetch methods from a DBAPI cursor. Alternate versions of this class may instead buffer the rows from cursors or not use cursors at all. r2c[Ulgr$_NO_CURSOR_DQLcursor_strategyrs r(rCursorFetchStrategy.soft_close !/r+c[Ulgr$r>rs r(rCursorFetchStrategy.hard_closerBr+cTURRUSSX!R5 gr$) connection_handle_dbapi_exceptionrQrs r(r$CursorFetchStrategy.handle_exceptions#11 t\>> r+cP[USU0[R"5SS9Ulg)Nmax_row_bufferr)initial_buffer growth_factor)BufferedRowCursorFetchStrategy collectionsdequer@rs r(rCursorFetchStrategy.yield_pers)!?  s #&,,. " r+cUR5nUcURUS9 U$![anURXU5 SnAgSnAff=fNhard)r  _soft_close BaseExceptionr)r&rrrrrFs r(r CursorFetchStrategy.fetchonesS ;'')C{"" "3J ;  ! !& : : ;s#& A AA NcUcUR5nOURU5nU(dUR5 U$![anURXU5 SnAgSnAff=fr$)rrUrVr)r&rrrlrFs r(rCursorFetchStrategy.fetchmanysa ;| **, **40""$H ;  ! !& : : ;s=A A& A!!A&cUR5nUR5 U$![anURXU5 SnAgSnAff=fr$)rrUrVr)r&rrrowsrFs r(rCursorFetchStrategy.fetchallsI ;((*D    K ;  ! !& : : ;s!$ A AA rr$)rrrrrrrrrrr rrrr2r+r(r<r<s1I00  ; ;;r+r<c^\rSrSrSrSrSSjr\S5rSr Sr U4Sjr U4S jr SS jr SS jrS rS rU=r$)rMiaA cursor fetch strategy with row buffering behavior. This strategy buffers the contents of a selection of rows before ``fetchone()`` is called. This is to allow the results of ``cursor.description`` to be available immediately, when interfacing with a DB-API that requires rows to be consumed before this information is available (currently psycopg2, when used with server-side cursors). The pre-fetching behavior fetches only one row initially, and then grows its buffer size by a fixed amount with each successive need for additional rows up the ``max_row_buffer`` size, which defaults to 1000:: with psycopg2_engine.connect() as conn: result = conn.execution_options( stream_results=True, max_row_buffer=50 ).execute(text("select * from table")) .. versionadded:: 1.4 ``max_row_buffer`` may now exceed 1000 rows. .. seealso:: :ref:`psycopg2_execution_options` )_max_row_buffer _rowbuffer_bufsize_growth_factorc"URSS5UlUbX@lO*[R"UR S55UlX0lU(a&[URUR 5UlgURUlg)NrJir) rr_r`rNrOrrbminra)r&rexecution_optionsrLrKs r(rv'BufferedRowCursorFetchStrategy.__init__sr 1445EtL  %,O)// 0F0Fq0IJDO+  4 4d6I6IJDM 00DMr+cV[URURR5$r$)rMcursorrQre)rrs r(create%BufferedRowCursorFetchStrategy.creates#- MM NN , ,  r+cURnUS:aUR5nOURU5nW(dg[ R "U5UlUR(a8X0R:a([URX0R-5Ulggg![anUR XU5 SnANSnAff=f)z*this is currently used only by fetchone().rN) rarrrVrrNrOr`rbr_rd)r&rrrnew_rowsrFs r( _buffer_rows+BufferedRowCursorFetchStrategy._buffer_rows"s}} ;ax'002'11$7 %++H5   4*>*>#>$$d-@-@&@DM$?   ;  ! !& : : ;sB$B$$ C .CC c.SUlU=UlUlgr)rbr_rars r(r(BufferedRowCursorFetchStrategy.yield_per6s/22t}r+c`>URR5 [[U]X5 gr$)r`clearsuperrMrr&rrr7s r(r)BufferedRowCursorFetchStrategy.soft_close:&  ,d>  r+c`>URR5 [[U]X5 gr$)r`rrrsrMrrts r(r)BufferedRowCursorFetchStrategy.hard_close@rvr+cUR(d3URX5 UR(dURUS9 gURR 5$![anUR XU5 SnAgSnAff=frR)r`rmrUrVrpopleft)r&rrrrFs r(r 'BufferedRowCursorFetchStrategy.fetchoneFsw   f 3??C&&J&7&&((%C))&BBCsA B)BBcUcURX5$[UR5n[U5nX5:a>UR X5- 5nU(dUR 5 OUR U5 USUn[R"XCS5UlU$![anURXU5 SnANESnAff=fr) rr3r`r[rrUextendrVrrNrO)r&rrrbuflbrUrFs r(r(BufferedRowCursorFetchStrategy.fetchmanyQs <==6 64??# X 9 $",,TY7&&(JJsOQt%++CJ7 ! ?%%fA>> ?sB C&B==Cc [UR5[UR55-nURR5 UR 5 U$![ anUR XU5 SnAgSnAff=fr$)r3r`rrrrUrVr)r&rrretrFs r(r'BufferedRowCursorFetchStrategy.fetchallfsl ;t'$|/D/D/F*GGC OO ! ! #    J ;  ! !& : : ;sAA B'A>>B)rarbr_r`)rNrr$)rrrrrrrvrrirmrrrr rrr __classcell__r7s@r(rMrMsY6PI  1(  (3  )*;;r+rMch^\rSrSrSrSrS SjrSrU4SjrU4Sjr S Sjr S S jr S r Sr U=r$) FullyBufferedCursorFetchStrategyipzA cursor strategy that buffers rows fully upon creation. Used for operations where a result is to be delivered after the database conversation can not be continued, such as MSSQL INSERT...OUTPUT after an autocommit. )r`rcX lUb[R"U5Ulg[R"UR 55Ulgr$)rrNrOr`r)r&ralternate_descriptionrKs r(rv)FullyBufferedCursorFetchStrategy.__init__{s>-B)  %)//?DO)// 0E0E0GHDOr+cgr$r2rs r(r*FullyBufferedCursorFetchStrategy.yield_perrr+c`>URR5 [[U]X5 gr$)r`rrrsrrrts r(r+FullyBufferedCursorFetchStrategy.soft_close&  .@  r+c`>URR5 [[U]X5 gr$)r`rrrsrrrts r(r+FullyBufferedCursorFetchStrategy.hard_closerr+cxUR(aURR5$URUS9 grR)r`rzrUr s r(r )FullyBufferedCursorFetchStrategy.fetchones0 ????**, ,   J  /r+cUcURX5$[UR5nUSUn[R"XCS5UlU(dUR 5 U$r)rr3r`rNrOrU)r&rrrr~r\s r(r*FullyBufferedCursorFetchStrategy.fetchmanysY <==6 64??#1T{%++CJ7     r+crURn[R"5UlUR5 U$r$)r`rNrOrU)r&rrrs r(r)FullyBufferedCursorFetchStrategy.fetchalls,oo%++- r+)NNrr$)rrrrrrrvrrrr rrrrrs@r(rrps??IHLI    r+rcX\rSrSrSrSrS SjrSrSrSr \ S 5r \ S 5r Sr g) _NoResultMetaDatair2FNcV[R"[R"S5US9 g)NzJThis result object does not return rows. It has been closed automatically.r)r rr r2)r&rs r(r9&_NoResultMetaData._we_dont_return_rowss&  # #4   r+c$UR5 gr$r9)r&r;rs r(r _NoResultMetaData._index_for_key !!#r+c$UR5 gr$rr%s r(r4$_NoResultMetaData._metadata_for_keysrr+c$UR5 gr$r)r&r;s r(rG_NoResultMetaData._reducerr+c$UR5 gr$rr&s r(r_NoResultMetaData._keymap !!#r+c$UR5 gr$rrs r(r;_NoResultMetaData.keysrr+r$)rrrrrrr9rr4rGpropertyrr;rr2r+r(rrsHIL $$$$$$$r+rc$\rSrSr\S5rSrg)_LegacyNoResultMetaDataic2[R"S5 /$)NzCalling the .keys() method on a result set that does not return rows is deprecated and will raise ResourceClosedError in SQLAlchemy 2.0.rrs r(r;_LegacyNoResultMetaData.keyss    r+r2N)rrrrrr;rr2r+r(rrs r+rc\rSrSrSrSrSrSrSrSr Sr SSjr \ S5r \ S 5rS rS r\ S 5r\ S 5rSrSrSrSrSr\R2S5r\ S5r\ S5r\ S5rSrg)BaseCursorResultiz'Base class for database result objects.NFc^ ^ ^ XlURUlURUlX lURUlUR R =(a URR5=UlnUbU(a.URR Rm U 4Sjm T Ul OSm URX5nURnURnURnURn [ R""XXvU 5m T (aU U 4Sjn OT n UR%SU 5 gUR&Ulg)NcB>T"S[R"U55 U$)NzRow %r)sql_util _repr_row)rlogs r(log_row*BaseCursorResult.__init__..log_rows("4"4S"9:Jr+c(>T"U5nT"U5 U$r$r2)rmade_row _make_rowrs r(make_row+BaseCursorResult.__init__..make_rows(~HH%#Or+ _row_getter)rQrYrhr@root_connectionrF_echoengine_should_log_debug _log_debug_row_logging_fn_init_metadatarr _process_row_default_key_style functoolspartial_set_memoized_attribute_no_result_metadatar8)r&rQr@riechometadatakeymap processors process_row key_stylerrrrs @@@r(rvBaseCursorResult.__init__s  nn .!11 OO ! ! Hgnn&F&F&H  T  ) ll--88(/$**7GH%%F!--J++K#66I!))z9I$ %  ( ( A"55DNr+cUR(GaURR(a!URRRnO2URX5nUR(aX1RlURnU(aUR (anUR URRLaKURRSS5(d*URURLaURU5nX0lOURX5=UlnUR(a,UR R#S[%SU555 U$)N _result_disable_adapt_to_contextFzCol %rc3*# UH oSv M g7f)rNr2).0xs r( 2BaseCursorResult._init_metadata..@sA.@!.@s)rJ_cached_metadatarQ_cursor_metadatar"rK cache_hitrY CACHE_HITrerrLrMrVr8rrFrtuple)r&rQrirrJs r(rBaseCursorResult._init_metadatas$    00<<00AA00J++8@$$5 ''H,,%%)B)BB11556&&g.G.GG#55g>%N)-(=(=) DNX ::    ) )%A.@AA r+cU(dUR(dU(aUR(agU(a-SUlURRXR5 O%URR XR5 UR(d6URnSUlUR RU5 SUlgg)aSoft close this :class:`_engine.CursorResult`. This releases all DBAPI cursor resources, but leaves the CursorResult "open" from a semantic perspective, meaning the fetchXXX() methods will continue to return empty results. This method is called automatically when: * all result rows are exhausted using the fetchXXX() methods. * cursor.description is None. This method is **not public**, but is documented in order to clarify the "autoclose" process used. .. versionadded:: 1.0.0 .. seealso:: :meth:`_engine.CursorResult.close` NT) _soft_closedr1r@rrhrrF_safe_close_cursor)r&rTrhs r(rUBaseCursorResult._soft_closeDs.**  DK  + +D++ >  + +D++ >  [[FDK OO . .v 6 $D  !r+cTURR(d[R"S5eURR(d[R"S5eURR (a[R"S5eURR $)aReturn the value of :attr:`_engine.CursorResult.inserted_primary_key` as a row contained within a list; some dialects may support a multiple row form as well. .. note:: As indicated below, in current SQLAlchemy versions this accessor is only useful beyond what's already supplied by :attr:`_engine.CursorResult.inserted_primary_key` when using the :ref:`postgresql_psycopg2` dialect. Future versions hope to generalize this feature to more dialects. This accessor is added to support dialects that offer the feature that is currently implemented by the :ref:`psycopg2_executemany_mode` feature, currently **only the psycopg2 dialect**, which provides for many rows to be INSERTed at once while still retaining the behavior of being able to return server-generated primary key values. * **When using the psycopg2 dialect, or other dialects that may support "fast executemany" style inserts in upcoming releases** : When invoking an INSERT statement while passing a list of rows as the second argument to :meth:`_engine.Connection.execute`, this accessor will then provide a list of rows, where each row contains the primary key value for each row that was INSERTed. * **When using all other dialects / backends that don't yet support this feature**: This accessor is only useful for **single row INSERT statements**, and returns the same information as that of the :attr:`_engine.CursorResult.inserted_primary_key` within a single-element list. When an INSERT statement is executed in conjunction with a list of rows to be INSERTed, the list will contain one row per row inserted in the statement, however it will contain ``None`` for any server-generated values. Future releases of SQLAlchemy will further generalize the "fast execution helper" feature of psycopg2 to suit other dialects, thus allowing this accessor to be of more general use. .. versionadded:: 1.4 .. seealso:: :attr:`_engine.CursorResult.inserted_primary_key` 1Statement is not a compiled expression construct.2Statement is not an insert() expression construct.z9Can't call inserted_primary_key when returning() is used.)rQrJr risinsert_is_explicit_returninginserted_primary_key_rowsrs r(r*BaseCursorResult.inserted_primary_key_rowsjs\||$$))F &&))G \\ 0 0))  ||555r+cURR(a[R"S5eURnU(aUS$g)aReturn the primary key for the row just inserted. The return value is a :class:`_result.Row` object representing a named tuple of primary key values in the order in which the primary key columns are configured in the source :class:`_schema.Table`. .. versionchanged:: 1.4.8 - the :attr:`_engine.CursorResult.inserted_primary_key` value is now a named tuple via the :class:`_result.Row` class, rather than a plain tuple. This accessor only applies to single row :func:`_expression.insert` constructs which did not explicitly specify :meth:`_expression.Insert.returning`. Support for multirow inserts, while not yet available for most backends, would be accessed using the :attr:`_engine.CursorResult.inserted_primary_key_rows` accessor. Note that primary key columns which specify a server_default clause, or otherwise do not qualify as "autoincrement" columns (see the notes at :class:`_schema.Column`), and were generated using the database-side default, will appear in this list as ``None`` unless the backend supports "returning" and the insert statement executed with the "implicit returning" enabled. Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed statement is not a compiled expression construct or is not an insert() construct. zuThis statement was an executemany call; if primary key returning is supported, please use .inserted_primary_key_rows.rN)rQ executemanyr rr)r&ikps r(inserted_primary_key%BaseCursorResult.inserted_primary_keysFB << # #))2  ,, q6Mr+cZURR(d[R"S5eURR(d[R"S5eURR (aURR $URR S$)zReturn the collection of updated parameters from this execution. Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed statement is not a compiled expression construct or is not an update() construct. rz2Statement is not an update() expression construct.r)rQrJr risupdatercompiled_parametersrs r(last_updated_params$BaseCursorResult.last_updated_params||$$))F &&))G \\ % %<<33 3<<33A6 6r+cZURR(d[R"S5eURR(d[R"S5eURR (aURR $URR S$)zReturn the collection of inserted parameters from this execution. Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed statement is not a compiled expression construct or is not an insert() construct. rrr)rQrJr rrrrrs r(last_inserted_params%BaseCursorResult.last_inserted_paramsrr+c.URR$)zReturn a list of rows each containing the values of default columns that were fetched using the :meth:`.ValuesBase.return_defaults` feature. The return value is a list of :class:`.Row` objects. .. versionadded:: 1.4 )rQreturned_default_rowsrs r(returned_defaults_rows'BaseCursorResult.returned_defaults_rowss||111r+cURR(a[R"S5eURRnU(aUS$g)aYReturn the values of default columns that were fetched using the :meth:`.ValuesBase.return_defaults` feature. The value is an instance of :class:`.Row`, or ``None`` if :meth:`.ValuesBase.return_defaults` was not used or if the backend does not support RETURNING. .. versionadded:: 0.9.0 .. seealso:: :meth:`.ValuesBase.return_defaults` zlThis statement was an executemany call; if return defaults is supported, please use .returned_defaults_rows.rN)rQrr rr)r&r\s r(returned_defaults"BaseCursorResult.returned_defaultssJ" << # #))D  ||11 7Nr+c6URR5$)zReturn ``lastrow_has_defaults()`` from the underlying :class:`.ExecutionContext`. See :class:`.ExecutionContext` for details. )rQlastrow_has_defaultsrs r(r%BaseCursorResult.lastrow_has_defaults,s||0022r+c(URR(d[R"S5eURR(d1URR (d[R"S5eURR $)aReturn ``postfetch_cols()`` from the underlying :class:`.ExecutionContext`. See :class:`.ExecutionContext` for details. Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed statement is not a compiled expression construct or is not an insert() or update() construct. r>Statement is not an insert() or update() expression construct.)rQrJr rrrpostfetch_colsrs r(rBaseCursorResult.postfetch_cols6sl||$$))F &&t||/D/D))( ||***r+c(URR(d[R"S5eURR(d1URR (d[R"S5eURR $)aReturn ``prefetch_cols()`` from the underlying :class:`.ExecutionContext`. See :class:`.ExecutionContext` for details. Raises :class:`~sqlalchemy.exc.InvalidRequestError` if the executed statement is not a compiled expression construct or is not an insert() or update() construct. rr)rQrJr rrr prefetch_colsrs r(rBaseCursorResult.prefetch_colsMsl||$$))F &&t||/D/D))( ||)))r+c.URR$)zpReturn ``supports_sane_rowcount`` from the dialect. See :attr:`_engine.CursorResult.rowcount` for background. )rYsupports_sane_rowcountrs r(r 'BaseCursorResult.supports_sane_rowcountds||222r+c.URR$)zvReturn ``supports_sane_multi_rowcount`` from the dialect. See :attr:`_engine.CursorResult.rowcount` for background. )rYsupports_sane_multi_rowcountrs r(r -BaseCursorResult.supports_sane_multi_rowcountms||888r+cURR$![a0nURR XR U5 SnAgSnAff=f)avReturn the 'rowcount' for this result. The 'rowcount' reports the number of rows *matched* by the WHERE criterion of an UPDATE or DELETE statement. .. note:: Notes regarding :attr:`_engine.CursorResult.rowcount`: * This attribute returns the number of rows *matched*, which is not necessarily the same as the number of rows that were actually *modified* - an UPDATE statement, for example, may have no net change on a given row if the SET values given are the same as those present in the row already. Such a row would be matched but not modified. On backends that feature both styles, such as MySQL, rowcount is configured by default to return the match count in all cases. * :attr:`_engine.CursorResult.rowcount` is *only* useful in conjunction with an UPDATE or DELETE statement. Contrary to what the Python DBAPI says, it does *not* return the number of rows available from the results of a SELECT statement as DBAPIs cannot support this functionality when rows are unbuffered. * :attr:`_engine.CursorResult.rowcount` may not be fully implemented by all dialects. In particular, most DBAPIs do not support an aggregate rowcount result from an executemany call. The :meth:`_engine.CursorResult.supports_sane_rowcount` and :meth:`_engine.CursorResult.supports_sane_multi_rowcount` methods will report from the dialect if each usage is known to be supported. * Statements that use RETURNING may not return a correct rowcount. .. seealso:: :ref:`tutorial_update_delete_rowcount` - in the :ref:`unified_tutorial` N)rQrowcountrVr@rrhr&rFs r(rBaseCursorResult.rowcountvsH` H<<(( ( H  1 1$ Q G G Hs A&A  AcURR5$![a0nURR XR U5 SnAgSnAff=f)aReturn the 'lastrowid' accessor on the DBAPI cursor. This is a DBAPI specific method and is only functional for those backends which support it, for statements where it is appropriate. It's behavior is not consistent across backends. Usage of this method is normally unnecessary when using insert() expression constructs; the :attr:`~CursorResult.inserted_primary_key` attribute provides a tuple of primary key values for a newly inserted row, regardless of database backend. N)rQ get_lastrowidrVr@rrhrs r( lastrowidBaseCursorResult.lastrowidsJ  H<<--/ / H  1 1$ Q G G Hs A&AAc.URR$)aTrue if this :class:`_engine.CursorResult` returns zero or more rows. I.e. if it is legal to call the methods :meth:`_engine.CursorResult.fetchone`, :meth:`_engine.CursorResult.fetchmany` :meth:`_engine.CursorResult.fetchall`. Overall, the value of :attr:`_engine.CursorResult.returns_rows` should always be synonymous with whether or not the DBAPI cursor had a ``.description`` attribute, indicating the presence of result columns, noting that a cursor that returns zero rows still has a ``.description`` if a row-returning statement was emitted. This attribute should be True for all results that are against SELECT statements, as well as for DML statements INSERT/UPDATE/DELETE that use RETURNING. For INSERT/UPDATE/DELETE statements that were not using RETURNING, the value will usually be False, however there are some dialect-specific exceptions to this, such as when using the MSSQL / pyodbc dialect a SELECT is emitted inline in order to retrieve an inserted primary key value. )r8rrs r(rBaseCursorResult.returns_rowss4~~***r+c.URR$)a4True if this :class:`_engine.CursorResult` is the result of a executing an expression language compiled :func:`_expression.insert` construct. When True, this implies that the :attr:`inserted_primary_key` attribute is accessible, assuming the statement did not include a user defined "returning" construct. )rQrrs r( is_insertBaseCursorResult.is_inserts||$$$r+) rr8rrr1rFrQrhr@rYr)rrrrrout_parametersr8rr1rvrrUrrrrrrrrrrr r r memoized_propertyrrrrrr2r+r(rrs1NIL F/6b.`$%L;6;6z++Z7,7, 2 283+.*.39 2H2HhHH(++6 % %r+rcx^\rSrSrSr\r\r\ r Sr Sr S Sjr SrSSjrSrU4S jrS r\S 5rS rU=r$) CursorResultiaA Result that is representing state from a DBAPI cursor. .. versionchanged:: 1.4 The :class:`.CursorResult` and :class:`.LegacyCursorResult` classes replace the previous :class:`.ResultProxy` interface. These classes are based on the :class:`.Result` calling API which provides an updated usage model and calling facade for SQLAlchemy Core and SQLAlchemy ORM. Returns database rows via the :class:`.Row` class, which provides additional API features and behaviors on top of the raw data returned by the DBAPI. Through the use of filters such as the :meth:`.Result.scalars` method, other kinds of objects may also be returned. Within the scope of the 1.x series of SQLAlchemy, Core SQL results in version 1.4 return an instance of :class:`._engine.LegacyCursorResult` which takes the place of the ``CursorResult`` class used for the 1.3 series and previously. This object returns rows as :class:`.LegacyRow` objects, which maintains Python mapping (i.e. dictionary) like behaviors upon the object itself. Going forward, the :attr:`.Row._mapping` attribute should be used for dictionary behaviors. .. seealso:: :ref:`coretutorial_selecting` - introductory material for accessing :class:`_engine.CursorResult` and :class:`.Row` objects. Tc#p# URRnU"XR5nUcgUv M7fr$r@r rh)r&r rs r(_fetchiter_implCursorResult._fetchiter_impls9''004-C{I s46cNURRXRU5$r$r!)r&rs r(_fetchone_implCursorResult._fetchone_impls##,,T;; KKr+cLURRXR5$r$)r@rrhrs r(_fetchall_implCursorResult._fetchall_impls##,,T;;??r+cNURRXRU5$r$)r@rrh)r&rs r(_fetchmany_implCursorResult._fetchmany_impls##--dKKFFr+c"UR5$r$)r"rs r(_raw_row_iteratorCursorResult._raw_row_iterator s##%%r+c>[[U] "U6nURR(+nU(a[ SU4U-55UlU$)Nc38# UHoRv M g7fr$)r)rrs r(r%CursorResult.merge..'s).>F.>s)rsrmerger8rsumr)r&others merged_resultsetup_rowcountsr7s r(r3CursorResult.merge#sRlD7@ "nn999 %()/3g.>)&M "r+c"URSS9 g)aClose this :class:`_engine.CursorResult`. This closes out the underlying DBAPI cursor corresponding to the statement execution, if one is still present. Note that the DBAPI cursor is automatically released when the :class:`_engine.CursorResult` exhausts all available rows. :meth:`_engine.CursorResult.close` is generally an optional method except in the case when discarding a :class:`_engine.CursorResult` that still has additional rows pending for fetch. After this method is called, it is no longer valid to call upon the fetch methods, which will raise a :class:`.ResourceClosedError` on subsequent use. .. seealso:: :ref:`connections_toplevel` TrSNrUrs r(closeCursorResult.close,s( d#r+c\XlURRXRU5 gr$) _yield_perr@rrh)r&rs r(rCursorResult.yield_perBs! &&t[[#>r+)r>rr$)rrrrrrrr<_cursor_strategy_cls_NO_RESULT_METADATAr _is_cursorr"r%r(r+r.r3r;rrrrrs@r(rrs[:,.-JL@G&$,??r+rcJ^\rSrSrSrSr\r\r \ r \ r SrSU4SjjrSrU=r$)LegacyCursorResultiHzLegacy version of :class:`.CursorResult`. This class includes connection "connection autoclose" behavior for use with "connectionless" execution, as well as delivers rows using the :class:`.LegacyRow` row implementation. .. versionadded:: 1.4 Fc"URSS9 g)aClose this :class:`_engine.LegacyCursorResult`. This method has the same behavior as that of :meth:`._engine.CursorResult`, but it also may close the underlying :class:`.Connection` for the case of "connectionless" execution. .. deprecated:: 2.0 "connectionless" execution is deprecated and will be removed in version 2.0. Version 2.0 will feature the :class:`_future.Result` object that will no longer affect the status of the originating connection in any case. After this method is called, it is no longer valid to call upon the fetch methods, which will raise a :class:`.ResourceClosedError` on subsequent use. .. seealso:: :ref:`connections_toplevel` :ref:`dbengine_implicit` TrSNr:rs r(r;LegacyCursorResult.closeZs0 d#r+c>URn[[U]US9 U(d?UR(a-UR(aUR R 5 ggggrR)rrsrDrU_autoclose_connectionrFr;)r&rT soft_closedr7s r(rULegacyCursorResult._soft_closetsU''   $33>!!** OO ! ! #+"r+r2r)rrrrrrHrrrrr<r@_LEGACY_NO_RESULT_METADATArr;rUrrrs@r(rDrDHs6"L1.4$4$$r+rDc\rSrSrSr\rSrg)BufferedRowResultProxyizA ResultProxy with row buffering behavior. .. deprecated:: 1.4 this class is now supplied using a strategy object. See :class:`.BufferedRowCursorFetchStrategy`. r2N)rrrrrrMr@rr2r+r(rMrMs:r+rMc\rSrSrSr\rSrg)FullyBufferedResultProxyizA result proxy that buffers rows fully upon creation. .. deprecated:: 1.4 this class is now supplied using a strategy object. See :class:`.FullyBufferedCursorFetchStrategy`. r2N)rrrrrrr@rr2r+r(rOrOs<r+rOc\rSrSrSrSrg)BufferedColumnRowiz&Row is now BufferedColumn in all casesr2N)rrrrrrr2r+r(rQrQs0r+rQc\rSrSrSr\rSrg)BufferedColumnResultProxyizA ResultProxy with column buffering behavior. .. versionchanged:: 1.4 This is now the default behavior of the Row and this class does not change behavior in any way. r2N)rrrrrrQrrr2r+r(rSrSs%Lr+rS):rrNrrrrrrrrr r sqlr r rsql.baser sql.compilerrrrrsymbolrr5r^r.r6r`r]rgrrobjectrrr/r?r6_NO_CURSOR_DMLr<_DEFAULT_FETCHrMrrrrArKrrrD ResultProxyrMrOrQrSr2r+r(r]s7"("""%+" [[ %     _ @>_ @DkD!5kD\&D$/$<4.*+ 34 3 *+9;-9;x%&D;%8D;N9':9x$$@/()46M%vM%`Z?#VZ?z4$4$n! :[:<{<1 1% %r+