/var/opt/nydus/ops/mysql/connector/__pycache__
Edit: /var/opt/nydus/ops/mysql/connector/__pycache__/cursor.cpython-312.pyc (58799B)
N j d Z ddlmZ ddlZddlZddlmZ ddlmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZ ddlmZ ddlmZ dd lmZ dd
lmZ dd lm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- erdd
l.m/Z/ dZ0 ejb de0 de0 dejd ejf z ejh z Z5 ejb dejd ejf z ejh z Z6 ejb de0 de0 dejd ejf z ejh z Z7 ejb dejd ejf z ejh z Z8 ejb d Z9 ejb dejt Z; ejb d Z< ejb d Z= ejb d Z> ejb d Z?d Z@d ZA G d d ZBd1d ZC G d! d"e ZD G d# d$eD ZE G d% d&eD ZF G d' d(eE ZG G d) d*eD ZH G d+ d,eD ZI G d- d.eIeE ZJ G d/ d0eIeH ZKy)2zCursor classes. ) annotationsN)Decimal)
TYPE_CHECKINGAnyDictIteratorListNoReturnOptionalSequenceTupleUnioncast )
deprecated)split_multi_statement)MySQLCursorAbstract)
ServerFlag)ErrorInterfaceErrorNotSupportedErrorProgrammingErrorReadTimeoutErrorWriteTimeoutErrorget_mysql_exception)
DescriptionType
EofPacketTypeParamsDictTypeParamsSequenceOrDictTypeParamsSequenceType
ResultType RowItemTypeRowType
StrOrBytes WarningType)MySQLConnectionz \/\*.*?\*\/(z)|(["'`][^"'`]*?(z)[^"'`]*?["'`])z<\s*ON\s+DUPLICATE\s+KEY(?:[^"'`]*["'`][^"'`]*["'`])*[^"'`]*$z |\s)*INSERT(z[|\s)*(?:IGNORE\s+)?INTO\s+[`'\"]?.+[`'\"]?(?:\.[`'\"]?.+[`'\"]?){0,2}\s+VALUES\s*(\(.+\)).*z.*VALUES\s*(\(.+\)).*s (%s)sV
%
\((?P
[^)]+)\)
(?P[diouxXeEfFgGcrs%])
s4 ;(?=(?:[^"'`]*(?:"[^"]*"|'[^']*'|`[^`]*`))*[^"'`]*$)s+ %s(?=(?:[^"'`]*["'`][^"'`]*["'`])*[^"'`]*$)z %\(.*?\)sz %\((.*?)\)szNo result set to fetch froml c 2 e Zd ZdZddZddZedd Zy) _ParamSubstitutorz4
Substitutes parameters into SQL statement.
c || _ d| _ y Nr )paramsindex)selfr, s G/opt/nydus/tmp/pip-target-a90h98xg/lib/python/mysql/connector/cursor.py__init__z_ParamSubstitutor.__init__| s '-
c | j }| xj dz
c_ t | j | S # t $ r
t d d w xY w)Nr z+Not enough parameters for the SQL statement)r- bytesr,
IndexErrorr )r. matchobjr- s r/ __call__z_ParamSubstitutor.__call__ sS
a
U+, , "=
s ; Ac F t | j | j z
S )z8Returns number of parameters remaining to be substituted)lenr, r- r. s r/ remainingz_ParamSubstitutor.remaining s 4;; $**,,r1 N)r, zSequence[bytes]returnNoner5 re.Matchr; r3 )r; int)__name__
__module__ __qualname____doc__r0 r6 propertyr: r1 r/ r) r) w s% - -r1 r) c @ dfd }t j || }|S )ah
>>> _bytestr_format_dict(b'%(a)s', {b'a': b'foobar'})
b'foobar
>>> _bytestr_format_dict(b'%%(a)s', {b'a': b'foobar'})
b'%%(a)s'
>>> _bytestr_format_dict(b'%%%(a)s', {b'a': b'foobar'})
b'%%foobar'
>>> _bytestr_format_dict(b'%(x)s %(y)s',
... {b'x': b'x=%(y)s', b'y': b'y=%(x)s'})
b'x=%(y)s y=%(x)s'
c d}| j }|d dk( rd}|d dk( r
|d }| }|t d|d |S )zReplace pattern.Nconversion_type % s mapping_keyz Unsupported conversion_type: ) groupdict
ValueError)r5 valuegroupskey
value_dicts r/ replacez%_bytestr_format_dict..replace st !%##% # $ ,E # $ , 'C sOE = /7H0I/JK
r1 r= )RE_PY_MAPPING_PARAMsub)bytestrrQ rR stmts ` r/ _bytestr_format_dictrW s!
" "7G 4D Kr1 c e Zd ZdZ d d fd
Zd!dZd"d#dZd$dZd%dZd&dZ d$dZ
d'd Z d(d
Z d)d Z
d%d Zd*d
Z d+ d,dZ d-dZ d.dZ ed d/d Z d0 d1dZd2dZd%dZd3dZd"d4dZd5dZd6d7dZd8dZ d9dZ e d:d Z e d$d Z d;d Z! xZ"S )< MySQLCursora Default cursor for interacting with MySQL
This cursor will execute statements and handle the result. It will
not automatically fetch all rows.
MySQLCursor should be inherited whenever other functionallity is
required. An example would to change the fetch* member functions
to return dictionaries instead of lists of values.
Implements the Python Database API Specification v2.0 (PEP-249)
c ^ t | ||| t d| j | _ y)
Initializer& N)superr0 r _connectionr.
connection read_timeout
write_timeout __class__s r/ r0 zMySQLCursor.__init__ s, \=A,01BDDTDT,Ur1 c . t | j d S )zm
Iteration over the result set which calls self.fetchone()
and returns the next row.
N)iterfetchoner9 s r/ __iter__zMySQLCursor.__iter__ s
DMM4((r1 c d| _ d| _ g | _ d| _ d| _ d| _ |s#d| _ g | _ d| _ d| _ d| _
| j y)a Reset the cursor to default.
Args:
preserve_last_executed_stmt: If it is False, the last executed
statement value is reset. Otherwise,
such a value is preserved.
NNNr F) _rowcount_nextrow_stored_results _warnings_warning_count _description _executed_executed_list_stmt_partitions_stmt_partition_stmt_map_resultsreset)r. preserve_last_executed_stmts r/
_reset_resultzMySQLCursor._reset_result sd !$
24 6:#$=A* !DN"$D $(D !#'D %*D "
r1 c N | j j S # t $ r Y yw xY w)z'Check whether there is an unread resultF)r]
unread_resultAttributeErrorr9 s r/ _have_unread_resultz MySQLCursor._have_unread_result s+ ##11 1 s $$c : | j t t y)zsCheck if the statement has been executed.
Raises an error if the statement has not been executed.
N)rp r ERR_NO_RESULT_TO_FETCHr9 s r/ _check_executedzMySQLCursor._check_executed s
>> ! !78 8 "r1 c ` | j }|st |S # t $ r t dw xY w)zm
Used for iterating over the result set. Calles self.fetchone()
to get the next row.
N)re r
StopIterationr. rows r/ __next__zMySQLCursor.__next__ s;
*--/C
* T ) *s -c | j y| j j | j d| _ y)zQClose the cursor
Returns True when successful, otherwise False.
NFT)r] handle_unread_resultrw r9 s r/ closezMySQLCursor.close s<
# --/ r1 c i } | j j }| j j j }| j j j }| j j j
}|j
D ]C \ }}|} || } || | } t |t s || } | ||j < E |S # t $ r}
t d|
|
d}
~
ww xY w)z,Process query parameters given as dictionaryz'Failed processing pyformat-parameters; N) r] sql_mode converterto_mysqlescapequoteitems
isinstancer encode Exceptionr ) r. r, resr r r r rP rN converrs r/ _process_params_dictz MySQLCursor._process_params_dict s !# ''00H''11::H%%//66F$$..44E $lln
U ~ dH-!%1 ;D$(CJJL!
-
"9#?
s C C C0 C++C0c 6 |dd } | j j }| j j j }| j j j }| j j j
}|D cg c]
} || }}|D cg c] } |||
}}t
| D cg c]" \ }}t || t s || n|$ }}}t | S c c}w c c}w c c}}w # t $ r} t d| | d} ~ ww xY w)zProcess query parameters.Nz%Failed processing format-parameters; ) r] r r r r r enumerater r r r tuple)
r. r, r r r r r rN ir s
r/ _process_paramszMySQLCursor._process_params( s Qi ''00H''11::H%%//66F$$..44E034u8E?C48;<u6%*C< !*# .HAu %/vay'$Be M .
Sz 5< "7u=
sB A:C; C+C; C0&C; 6'C5 C; +C; ; DDDc |d | _ |d | _ |d | _ | j
y# t t f$ r}t d| dd}~ww xY w)z7Handles result of execute() when there is no result set
affected_rows insert_id
warning_countz Failed handling non-resultset; N)rj _last_insert_idrn KeyError TypeErrorr _handle_warnings)r. r r s r/ _handle_noresultsetz MySQLCursor._handle_noresultset> sk V 1DN#&{#3D "%o"6D
)$ V"%DSE#JKQU U Vs 1 A AAc y)zHandles result set
This method handles the result set and is called after reading
and storing column information in _handle_result(). For non-buffering
cursors, this method is usually doing nothing.
NrE r9 s r/ _handle_resultsetz MySQLCursor._handle_resultsetI r1 c t |t s t d d|v r,|d | _ d| j _ | j
yd|v r#d| j _ | j | yt d )z
Handle the result after a command was send. The result can be either
an OK-packet or a dictionary containing column/eof information.
Raises InterfaceError when result is not a dict() or result is
invalid.
zResult was not a dict()columnsTr FzInvalid resultN)r dictr ro r] ry r r r. results r/ _handle_resultzMySQLCursor._handle_resultQ sy &$' !:; ; &y 1D -1D * " " $
&-2D * $ $V , !12 2r1 c |sy | j st | j j | j d} t |t r&|j | j j }nt t | }|rt |t r t || j | }nt |t t" f rJt% | j' | }t( j+ || }|j, dk7 r0t d t dt/ | j0 d| d t3 || | _ t7 | j4 | _ || _ | j8 d | _ |r | j8 d j? n| j8 d
| _ | jC | j jE | j8 d
| jF | jH y # t t f$ r}t d |d }~ww xY w# t t f$ r}t t
| |d }~ww xY w) NzCursor is not connectedr1 r 1Not all parameters were used in the SQL statementz Could not process parameters: r' z)), it must be of type list, tuple or dict)sql_code map_results single_stmts
mappable_stmtr` ra )%r] r ReferenceErrorr rw r strr python_charsetr r3 UnicodeDecodeErrorUnicodeEncodeErrorr rW r listr r) r RE_PY_PARAMrT r: typer@ r rr nextrs rt rq popleftrp r cmd_query
_read_timeout_write_timeout)r. operationr, r r rV psubs r/ executezMySQLCursor.executeh s< G##&& $
--/ 6)S) ''(8(8(G(GHE9- &$'+D$2K2KF2STFT5M2()=)=f)EF"tT2>>Q&*K '4T&\5J5J4K1VH U> >
!6{!
$D$9$9 : !, " 2 2> B
0 8 8 :%%o6
& &$$_5 ! / / " 1 1
'
g !.1 G"#<=3 F G #$67 6"3s8,# 5 6s0 H AH* H' H""H'*I9IIc d
d}t j t dt j t || }t j t
| }|s t
d |j d j | j j }g } |j | j j }|D ] } |}t | t r t || j | }nJt | j! | }
t" j |
| }|
j$ dk7 r t' d |j) | ||v r+|j+ |dj- | d }|| _ |S y# t0 t2 f$ r} t' t5 | | d} ~ wt6 $ r t8 $ r} t
d | dd} ~ ww xY w) zImplements multi row insertc H | j d ry| j d S )a Remove comments from INSERT statements.
This function is used while removing comments from INSERT
statements. If the matched string is a comment not enclosed
by quotes, it returns an empty string, else the string itself.
r )group)matchs r/ remove_commentsz2MySQLCursor._batch_insert..remove_comments s {{1~;;q> !r1 r zAFailed rewriting statement for multi-row INSERT. Check SQL syntaxr r r ,N Failed executing the operation; )r r> r; r ) rerT RE_SQL_ON_DUPLICATERE_SQL_COMMENTsearchRE_SQL_INSERT_VALUESr r r r] r r r rW r r) r r r: r appendrR joinrp r r r r r ) r. r
seq_paramsr tmpmatchesfmtvaluesrV r, r r s r/
_batch_insertzMySQLCursor._batch_insert s
" ff FF>?I >
)) 0#6 S
mmA %%d&6&6&E&EF U ##D$4$4$C$CDD$ fd+.sD4M4Mf4UVC,T-A-A&-IJD%//$4C~~* . O
c" % d{||C6):A>!% "$67 6"3s8,# 5 U #CC5!IJPT T Us% C#E< <G F G 5GG c > |r|sy| j j t | }t j t | r6|sd| _ y| j || }||| _
| j | S d} |D ]O }| j || | j r | j r| j || j z
}Q || _ y# t $ r}t d |d}~ww xY w# t t f$ r}t! d| dd}~ww xY w)a Execute the given operation multiple times
The executemany() method will execute the operation iterating
over the list of parameters in seq_params.
Example: Inserting 3 new employees and their phone number
data = [
('Jane','555-001'),
('Joe', '555-001'),
('John', '555-003')
]
stmt = "INSERT INTO employees (name, phone) VALUES ('%s','%s)"
cursor.executemany(stmt, data)
INSERT statements are optimized by batching the data, that is
using the MySQL multiple rows syntax.
Results are discarded. If they are needed, consider looping over
data using the execute() method.
Nz(Parameters for query must be an Iterabler r )r] r rd r r r r RE_SQL_INSERT_STMTrj r rp r with_rowsr{ fetchallrM r )r. r r _r rV rowcntr, s r/ executemanyzMySQLCursor.executemany s# 0
--/ XZ A
88& 2 !"%%i>d&>&>&@MMO$..( % / X"#MNTW W X( I& U #CC5!IJPT T Us0 C ?AC9 C6% C11C69D DD zmThe property counterpart 'stored_results' will be added in a future release, and this method will be removed.c , t | j S )zReturns an iterator for stored results
This method returns an iterator over results which are stored when
callproc() is called. The iterator will provide MySQLCursorBuffered
instances.
Returns a iterator.
)rd rl r9 s r/ stored_resultszMySQLCursor.stored_results s D(())r1 c > |rt |t s t d t |t t f s t d d}g | _ g } g }g }|j
d d }|rg }t | D ] \ } }
|j || dz } |j | t |
t r0|j d| d |
d d
|j |
d m|j | |j |
d j d
|D } | j d| | d| dd j | d
}
| j j }| j j |
| j | j D ] }d| j _
t | t" t$ f rt$ }n| j& rt( }nt* } || j j- }d|
d
|_ |j1 | |j2 |j2 | _ d|v s|j | || j _
|r|t7 ||D
cg c] }
|
j9 d c}
D cg c] \ }}| d | }}}dd j | }| j | || _ | j; S || _ t S c c}
w c c}}w # t< $ r t> $ r}tA d| dd}~ww xY w)a Calls a stored procedure with the given arguments
The arguments will be set during this session, meaning
they will be called like ___arg where
is an enumeration (+1) of the arguments.
Coding Example:
1) Defining the Stored Routine in MySQL:
CREATE PROCEDURE multiply(IN pFac1 INT, IN pFac2 INT, OUT pProd INT)
BEGIN
SET pProd := pFac1 * pFac2;
END
2) Executing in Python:
args = (5, 5, 0) # 0 is to hold pprod
cursor.callproc('multiply', args)
print(cursor.fetchone())
For OUT and INOUT parameters the user should provide the
type of the parameter as well. The argument should be a
tuple with first item as the value of the parameter to pass
and second argument the type of the argument.
In the above example, one can call callproc method like:
args = (5, 5, (0, 'INT'))
cursor.callproc('multiply', args)
The type of the argument given in the tuple will be used by
the MySQL CAST function to convert the values in the corresponding
MySQL type (See CAST in MySQL Reference for more information)
Does not return a value, but a result set will be
available when the CALL-statement execute successfully.
Raises exceptions when something is wrong.
zprocname must be a stringzargs must be a sequencez@_{name}_arg{index}.rh r )namer- z CAST(z AS )r ,c 3 & K | ] }| d yw)z=%sNrE ).0args r/ z'MySQLCursor.callproc..m s 'Hx3%s x zSET zCALL r' r Fz
(a result of Nr z@_zSELECT z Failed calling stored routine; )!r r rM r r rl splitr formatr r r r] can_consume_resultscmd_query_iterr r MySQLCursorDictMySQLCursorBufferedDict_rawMySQLCursorBufferedRawMySQLCursorBufferedget_selfrp r warningsrm ziplstripre r r r )r. procnameargsargfmtresultsargnamesargtypes procname_abs argvaluesidxr argname placeholderscallr r cursor_classcurr aliasselectr s r/ callproczMySQLCursor.callproc' s P z(C 8 89 9$
. 67 7& ! D THH
$>>#.r2L )$HC $mm S1Wm MG OOG,!#u- & c!fXQ(GH!((Q0 0!((- !0 #xx'Hx'H H tL> 2I>8*Achhx&8%9;D #'"2"2"F"F **994#5#5TEXEX : 8= 4 d_6M$NO#:LYY#9L#6L"4#3#3#<#<#>?"/vQ 7
""6*<<+%(\\DN &NN3'%& 4GD 0 (+ x"Hx3::d#3x"H(( e fD(( #388D>"23 V$'.$}}&#*D 7N #I T #B3%!HIt S TsC G,K6 80K6 (K+
K6
K0>K6 K6 + K6 6L LL c g } | j j d| j | j }|j d |j }|j
|r|S y# t $ r}t d| dd}~ww xY w)z
Fetch warnings doing a SHOW WARNINGS. Can be called after getting
the result.
Returns a result set or None when there were no warnings.
F)rawr` ra z
SHOW WARNINGSzFailed getting warnings; N) r] cursorr r r r r r r )r. r r r s r/ _fetch_warningszMySQLCursor._fetch_warnings s
N"")) ! / / " 1 1 * C
KK (,,.C IIK J
N #|dz }| j }|r|j | |dkD r| j r>|S a< Return the next set of rows of a query result set.
When no more rows are available, it returns an empty list.
The number of rows returned can be specified using the size argument,
which defaults to one.
Returns:
list: The next set of rows of a query result set.
r r )r~ arraysizer{ re r r. sizer cntr s r/ fetchmanyzMySQLCursor.fetchmany sr
$dnnAg$224 1HC--/C
3 Ag$224
r1 c | j | j sg S | j j | j \ }}| j
d r |j
d| j
d | j | t | }|dk\ r| j dk( rd| _ | xj |z
c_ |S )Return all rows of a query result set.
Returns:
list: A list of tuples with all rows of a query result set.
r` r rh )
r~ r{ r] get_rowsr rk insertr r8 rj r. rowsr rowcounts r/ r zMySQLCursor.fetchall s
'')I&&//T=O=O/P s == KK4==+ , t9 q=T^^r 1 DN (" r1 c f | j j r| j j | j d | j | j j | j j
j
| j | j S| j rG| j d st j d y| j d j | _ y| j t | j | _
| j d j | _ | j | j j! | j d | j | j" y| j y # t$ $ r Y w xY w)NT)rv r- r zOMappingWarning: Number of result sets greater than number of single statements.r r )r] _have_next_resultr rw r _socketrecvr rr rt rs r r r rp r r r r r9 s r/ nextsetzMySQLCursor.nextset. s - - 1 1 3 4 @ //$$,,11t?Q?Q1R
$$0T5K5K++N; MM0 &*%9%9.%I%Q%Q%SDN ,
'+D,A,A'B$ "&!5!5n!E!M!M!O##$$.. ,,_=%)%7%7&*&9&9 / # !
s F$ $ F0/F0c f | j s
t S t d | j D S )ztReturns column names
This property returns the columns names as a tuple.
Returns a tuple.
c 3 & K | ] }|d yw)r NrE )r ds r/ r z+MySQLCursor.column_names..o s 4#3aQqT#3r )r r r9 s r/ column_nameszMySQLCursor.column_namese s+ 7N44#3#3444r1 c | j syy)zReturns whether the cursor could have rows returned
This property returns True when column descriptions are available
and possibly also rows, which will need to be fetched.
Returns True or False.
FT)r r9 s r/ r zMySQLCursor.with_rowsq s r1 c d}| j r3 | j j d }t | dkD r |d d dz }nd}|j | j
j | S # t $ r | j }Y Ww xY w)Nz{class_name}: {stmt}zutf-8( z..z(Nothing executed yet))
class_namerV )rp decoderz r8 r rb r@ )r. r executeds r/ __str__zMySQLCursor.__str__~ s $ >>
* >>009 8}r!#CR=4//HzzT^^%<%<8zLL
"
* >>
*s A+ +BBNNNr_ Optional[MySQLConnection]r`
Optional[int]ra rF r; r< )r; zIterator[RowType]F)rv boolr; r< r; rH r; r< )r; r# )r, r r; z"Dict[bytes, Union[bytes, Decimal]])r, r r; z!Tuple[Union[bytes, Decimal], ...]r r! r; r< r r! r; r< NF)r r r, "Optional[ParamsSequenceOrDictType]r rH r; r< )r r r "Sequence[ParamsSequenceOrDictType]r; zOptional[bytes])r r r rO r; r< )r; zIterator[MySQLCursor]rE )r r r r r; z0Optional[Union[Dict[str, RowItemType], RowType]])r; zOptional[List[WarningType]]r r r; r< r rH r; Optional[RowType]r; rS Nr( rF r;
List[RowType]r; rW )r; zOptional[bool])r; zTuple[str, ...])r; r )#r@ rA rB rC r0 rf rw r{ r~ r r r r r r r r r r r r r r
r r r re r* r r7 rD r; r rB
__classcell__rb s @r/ rY rY s
15&*'+ V-V $V % V
V)29 $ +.( *, 34 6: ! ?? 3? ?
?B6U 6U*L6U 6Up5 5*L5
5n + * * vTvT vT
: vTp2). $L!(*5n 5 5
Mr1 rY c e Zd ZdZ d
d fd
Zd dZd
ddZdddZddZddZ dddZ
e dd Z xZ
S )r z*Cursor which fetches rows within execute()c D t | ||| d | _ d| _ y r+ )r\ r0 _rows _next_rowr^ s r/ r0 z MySQLCursorBuffered.__init__ s$ \=A.2
r1 c | j j | j \ | _ }t | j | _ | j
| d| _ d| j _ y # t $ r Y y w xY w)Nr- r F)
r] r. r r] r8 rj r r^ ry rz r s r/ r z%MySQLCursorBuffered._handle_resultset sq , , 5 54CUCU 5 VS TZZ -2D * s "A4 4 B ?B c d | _ y rU r] r. frees r/ ru zMySQLCursorBuffered.reset s
r1 c d } | j | j }| xj dz
c_ |S # t t f$ r Y y w xY w)Nr )r] r^ r4 r )r. r r s r/ r z MySQLCursorBuffered._fetch_row sL **T^^,C
!
I& s 4 AAc B | j | j S r r" r9 s r/ re z MySQLCursorBuffered.fetchone r# r1 c | j | j t t g }| j | j d }t | j | _ |S r, N)rp r] r r} r^ r8 )r. r s r/ r z MySQLCursorBuffered.fetchall sQ >> !TZZ%7 !78 8jj )* TZZ
r1 c | j g }|xs | j }|dkD r.|dz }| j }|r|j | |dkD r.|S r% )r~ r& re r r' s r/ r* z MySQLCursorBuffered.fetchmany s\
$dnnAg 1HC--/C
3 Ag
r1 c | j d uS rU ra r9 s r/ r z MySQLCursorBuffered.with_rows zz%%r1 rC rD rJ Trc rH r; r< rG rR rT rX rU rV rI )r@ rA rB rC r0 r ru r re r r* rD r rY rZ s @r/ r r sn 4 15&*'+ - $ %
! * & &r1 r c J e Zd ZdZ d d fd
ZddZddZ xZS ) MySQLCursorRawzS
Skips conversion from MySQL datatypes to Python types when fetching rows.
c 6 t | ||| d| _ y NTr\ r0 r r^ s r/ r0 zMySQLCursorRaw.__init__ \=A r1 c Z | j | j | j S )r! )r )r~ r r r9 s r/ re zMySQLCursorRaw.fetchone s%
499--r1 c | j | j sg S | j j | j | j
\ }}| j d r |j d| j d | j | t | }|dk\ r| j dk( rd| _
| xj |z
c_
|S )r, r r` r rh ) r~ r{ r] r. r r rk r/ r r8 rj r0 s r/ r zMySQLCursorRaw.fetchall s
'')I&&// (:(: 0
s == KK4==+ , t9 q=T^^r 1 DN (" r1 rC rD rT rX )r@ rA rB rC r0 re r rY rZ s @r/ rn rn sH 15&*'+ - $ %
.r1 rn c d e Zd ZdZ d d fd
Zd dZd
dZd dZed d Z xZ
S )
r z
Cursor which skips conversion from MySQL datatypes to Python types when
fetching rows and fetches rows within execute().
c 6 t | ||| d| _ y rp rq r^ s r/ r0 z MySQLCursorBufferedRaw.__init__ rr r1 c | j j | j | j \ | _ }t | j | _ | j | d| _ d| j _ y # t $ r Y y w xY w)Nru r F) r] r. r r r] r8 rj r r^ ry rz r s r/ r z(MySQLCursorBufferedRaw._handle_resultset s~ , , 5 5 (:(: 6
S TZZ -2D * s -A? ? B
B c B | j | j S r r" r9 s r/ re z MySQLCursorBufferedRaw.fetchone' r# r1 c | j | j g S t | j | j d S rg )r~ r] r r^ r9 s r/ r z MySQLCursorBufferedRaw.fetchall0 s:
:: IDJJt~~ /011r1 c | j d uS rU ra r9 s r/ r z MySQLCursorBufferedRaw.with_rows; rj r1 rC rD rJ rT rX rI ) r@ rA rB rC r0 r re r rD r rY rZ s @r/ r r sa 15&*'+ - $ %
! 2 & &r1 r c e Zd ZdZ d d fd
ZdddZd fd ZddZd fd ZdddZ d fd Z
ddd Z d d
Z d d d Z
d d Zd d
Zdd!dZd"dZ xZS )#MySQLCursorPreparedz&Cursor using MySQL Prepared Statementsc t | ||| d | _ d| _ d | _ d| _ d | _ d| _ d| _ y )Nr TF) r\ r0 r] r^ _preparedr _have_result_last_row_sent_cursor_existsr^ s r/ r0 z MySQLCursorPrepared.__init__C sJ \=A.2
QU ! ,0$)$)r1 c | j rG | j j | j d | j | j d | _ d | _ d| _ d| _ y # t
$ r Y (w xY w)N statement_idr F) r r] cmd_stmt_closer r r rp r r rb s r/ ru zMySQLCursorPrepared.resetR sy >>
//NN>2!%!3!3"&"5"5 0 "DN # #
s ?A* * A65A6c | j |j d|j dd t |
| y N status_flag
server_statusr )_handle_server_statusgetr\ r )r. r rb s r/ r z'MySQLCursorPrepared._handle_noresultsetb s5 ""377=#''/ST:U#VW
#C(r1 c p |t j z dk7 | _ |t j z dk7 | _ y)zoCheck for SERVER_STATUS_CURSOR_EXISTS and
SERVER_STATUS_LAST_ROW_SENT flags set by the server.
r N)r STATUS_CURSOR_EXISTSr STATUS_LAST_ROW_SENTr )r. flagss r/ r z)MySQLCursorPrepared._handle_server_statusf s4 $j&E&E E J #j&E&E E Jr1 c | j |j d|j dd t |
| y r )r r r\ r )r. r rb s r/ r z MySQLCursorPrepared._handle_eofm s5 ""377=#''/ST:U#VW
C r1 c t )zQCalls a stored procedue
Not supported with MySQLCursorPrepared.
)r )r. r r s r/ r z MySQLCursorPrepared.callprocq s
!!r1 c B | j t | y)zzClose the cursor
This method will try to deallocate the prepared statement and close
the cursor.
N)ru r\ r r. rb s r/ r zMySQLCursorPrepared.closex s
r1 c y)zConvert row data from MySQL to Python types
The conversion is done while reading binary data in the
protocol module.
NrE r. rowdatadescs r/ _row_to_pythonz"MySQLCursorPrepared._row_to_python r r1 c 8 t |t r*d| j _ d| _ | j | y|d | _ d| j _ d| _ d|d v r| j |d d yd|d v r| j |d d yy)z Handle result after executionFr Tr r r N)r r r] ry r r ro r r s r/ r z"MySQLCursorPrepared._handle_result s fd #-2D * %D $ $V , &q D -1D * $D q )**6!9]+CD F1I-**6!9_+EF .r1 c | |r t d | j j }|dk( rd}t |t s |j | }t t rJt j t | } t fd|D t j t d| }|| j ur| j r?| j j# | j d | j$ | j& || _ |j) | }d
|v rt j t, d | } | j j/ || j$ | j& | _ | j j3 | j d | j$ | j& | j d rsyrnt t t4 f s't d
dt7 j8 d d t; | j d t; k7 r
t d
d d | j j= | j d | j d | j$ | j& }| j? | y# t $ r}t t | |d}~ww xY w# t $ r}t d |d}~ww xY w# t* $ r}t t | |d}~ww xY w# t0 $ r d| _ w xY w# t@ tB f$ r}| jE |d}~ww xY w)a Prepare and execute a MySQL Prepared Statement
This method will prepare the given operation and execute it using
the optionally given parameters.
If the cursor instance already had a prepared statement, it is
first closed.
*Argument "map_results" is unused as multi statement execution
is not supported for prepared statements*.
Raises:
ProgrammingError: When providing a multi statement operation
or setting *map_results* to True.
z@Multi statement execution not supported for prepared statements.utf8mb4utf8Nc 3 ( K | ] }| y wrU rE )r rP r, s r/ r z.MySQLCursorPrepared.execute.. s G6Fsvc{6Fs z6Not all placeholders were found in the parameters dict?r r s %s ?
parametersi z Incorrect type of argument: r' zP), it must be of type tuple or list the argument given to the prepared statement)errnomsgz:Incorrect number of arguments executing prepared statementrE )datar r` ra )#r r] charsetr r r@ r r r findall RE_SQL_PYTHON_CAPTURE_PARAM_NAMEr r rT RE_SQL_PYTHON_REPLACE_PARAMrp r r r r r r RE_SQL_FIND_PARAMcmd_stmt_preparer cmd_stmt_resetr r r@ r8 cmd_stmt_executer r r ru )r. r r, r r r replacement_keysr s ` r/ r zMySQLCursorPrepared.execute s/ * "R
""** i G)S)
: % , ,W 5 fd # !zz*JI V
G6F GG :CKI DNN *~~ //NN>2!%!3!3"&"5"5 0
'DN
: % , ,W 5 ! FF#4dI F
!%!1!1!B!B !%!3!3"&"5"5 "C "
'' NN> * ++ -- (
>>, ' fudm4& 6tF|7L7L6MQvh W- - 4>>,/0CK?& T
>F ""33~. >>,7 ! / / " 1 1 4 C
$W &
:&s3x0c9
:
&L
$ &
:&s3x0c9
:
!%
J !"34 JJLI sl J 9J= K :7L 7A L J: J55J:= K KK K=#K88K= LL;$L66L;c d} |D ]O }| j || | j r | j r| j || j z
}Q || _ y# t
t f$ r}t d| dd}~ww xY w)aD Prepare and execute a MySQL Prepared Statement many times
This method will prepare the given operation and execute with each
tuple found the list seq_params.
If the cursor instance already had a prepared statement, it is
first closed.
executemany() simply calls execute().
r r N)r r r{ r rj rM r r )r. r r r r, r s r/ r z MySQLCursorPrepared.executemany s U$ Y/>>d&>&>&@MMO$..( % I& U #CC5!IJPT T Us AA! !B0A??Bc | j | j r?| j j | j d | j
| j | j xs dS )r! r r N)r~ r r] cmd_stmt_fetchr r r r r9 s r/ re z MySQLCursorPrepared.fetchone# sd
+ +~. ! / / " 1 1
,
(D(r1 c | j g }|xs | j }|dkD rN| j r>|dz }| j }|r|j | |dkD r| j r>|S r% )r~ r& r{ r r r' s r/ r* z MySQLCursorPrepared.fetchmany2 ss
$dnnAg$224 1HC//#C
3 Ag$224
r1 c H | j g }| j d r |j | j d | j r| j rD| j
j
| j d t | j | j | j
j | j | j | j \ }}|j | | j | | j rt! | | _ |S )r, r r r )r r r` )r~ rk r r{ r r] r r MAX_RESULTSr r r. r r extendr r8 rj )r. r1 r r s r/ r z MySQLCursorPrepared.fetchallF s
== KK
a( )&&("" //NN>2 !%!3!3"&"5"5 0 ))22|| (( ! / / 3 JS#
KK S ! &&( T r1 rC )r_ rE r` rF ra rF rk rl rK )r r? r; r< rQ rP )r r r r r; r
rJ rU )r r r r r; r rL rM )r r$ r, rN r rH r; r< )r r r z Sequence[ParamsSequenceType]r; r< rT rV rX )r@ rA rB rC r0 ru r r r r r r r r r re r* r rY rZ s @r/ r} r} @ s 0 15&*'+
*-
* $
* %
* $ )K!" G& 6: ! o o 3o o
ob 1
4
) (r1 r} c F e Zd ZdZ d ddZd fd Zd fd Z xZS ) r z
Cursor fetching rows as dictionaries.
The fetch methods of this class will return dictionaries instead of tuples.
Each row is a dictionary that looks like:
row = {
"col1": value1,
"col2": value2
}
c H |r t t | j | S dS )zWConvert a MySQL text result row to Python types
Returns a dictionary.
N)r r r; r s r/ r z MySQLCursorDict._row_to_pythono s$ 9@tC))734ITIr1 c T | j t | | j S )zyReturn next row of a query result set.
Returns:
dict or None: A dict from query result set.
)r r\ re r r s r/ re zMySQLCursorDict.fetchonez s& ""57#3#5t7G7GHHr1 c ~ t | D cg c] }|r | j || j " c}S c c}w )zReturn all rows of a query result set.
Returns:
list: A list of dictionaries with all rows of a query
result set where column names are used as keys.
)r\ r r r )r. r rb s r/ r zMySQLCursorDict.fetchall sH w')
)
T%5%5 6)
s %:rU )r r# r z Optional[List[DescriptionType]]r; Optional[Dict[str, RowItemType]]r; r r; z&List[Optional[Dict[str, RowItemType]]])r@ rA rB rC r re r rY rZ s @r/ r r c sB 15 J J . J
* JI
r1 r c e Zd ZdZddZddZy)r z8
Buffered Cursor fetching rows as dictionaries.
c | j | j }|r | j || j S y)r! N)r~ r r r r s r/ re z MySQLCursorBufferedDict.fetchone s;
oo &&sD,<,<= =r1 c | j | j t t g }| j | j d D ]- }|j | j
|| j / t | j | _ |S rg ) rp r] r r} r^ r r r r8 )r. r r s r/ r z MySQLCursorBufferedDict.fetchall su >> !TZZ%7 !78 8::dnn ./C JJt**30@0@A B 0 TZZ
r1 Nr r )r@ rA rB rC re r rE r1 r/ r r s
r1 r c & e Zd ZdZdd fd
Z xZS )MySQLCursorPreparedDicta
This class is a blend of features from MySQLCursorDict and MySQLCursorPrepared
Multiple inheritance in python is allowed but care must be taken
when assuming methods resolution. In the case of multiple
inheritance, a given attribute is first searched in the current
class if it's not found then it's searched in the parent classes.
The parent classes are searched in a left-right fashion and each
class is searched once.
Based on python's attribute resolution, in this case, attributes
are searched as follows:
1. MySQLCursorPreparedDict (current class)
2. MySQLCursorDict (left parent class)
3. MySQLCursorPrepared (right parent class)
4. MySQLCursor (base class)
c t | | D cg c] }|r | j || j " c}S c c}w )a Return the next set of rows of a query result set.
When no more rows are available, it returns an empty list.
The number of rows returned can be specified using the size argument,
which defaults to one.
Returns:
list: The next set of rows of a query result set represented
as a list of dictionaries where column names are used as keys.
)r( )r\ r* r r )r. r( r rb s r/ r* z!MySQLCursorPreparedDict.fetchmany sM w(d(3
3
T%5%5 63
s %<rU )r( rF r; z List[Dict[str, RowItemType]])r@ rA rB rC r* rY rZ s @r/ r r s "
r1 r )rU r3 rQ zDict[bytes, bytes]r; r3 )LrC
__future__r r r decimalr typingr r r r r r
r r r
r r _decoratingr
_scriptingr abstractsr constantsr errorsr r r r r r r typesr r r r r r! r" r# r$ r% r_ r& SQL_COMMENTcompileIMSr r r r r XrS RE_SQL_SPLIT_STMTSr r r r} r r) rW rY r rn r r} r r r rE r1 r/ r sJ > " $ - * ! +
;-(
_GDD244K"$$ !bjjGDD244K"$$ RZZ
\+ /# # DD244K"$$ "rzz":BDD244K"$$