pyGoEdge-UserPanel/.venv/Lib/site-packages/pymysql/__pycache__/cursors.cpython-312.pyc

<EFBFBD>
g<>
i<>@<00><00><><00>dd
lZdd
l
Z
ddlmZ
ejdej
ejz<00>ZGd<05>d<06>ZGd<07>d<08>Z	Gd	<09>d
e	e<08>Z
Gd<0B>de<08>ZGd
<0A>de	e<0B>Zy
)<0F>N<>
)
<01>errz|\s*((?:INSERT|REPLACE)\b.+\bVALUES?\s*)(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))(\s*(?:ON DUPLICATE.*)?);?\s*\Zc<00><><00>eZ
dZd
ZdZd<03>Zd<04>Zd<05>Zd<06>Zd<07>Z	d<08>Z
d	<09>Zd
<EFBFBD>Zd<0B>Z
dd<0C>
Zd
<0A>Zd<0E>Zd d<10>
Zd d<11>
Zd<12>Zd<13>Zd!d<14>
Zd<15>Zd d<16>
Zd<17>Zd"d<18>
Zd<19>Zd<1A>Zd<1B>Zd<1C>Zd<1D>Zd<1E>Zy)#<23>Cursora

    This is the object used to interact with the database.

    Do not create an instance of a Cursor yourself. Call
    connections.Connection.cursor().

    See `Cursor <https://www.python.org/dev/peps/pep-0249/#cursor-objects>`_ in
    the specification.
    i<00>c<00><><00>|
|_d
|_
d|_d
|_d|_d|_d|_d|_d|_y)Nr<00><><EFBFBD><EFBFBD><EFBFBD>r)	<09>
connection<EFBFBD>
warning_count<6E>description<6F>	rownumber<65>rowcount<6E>	arraysize<7A>	_executed<65>_result<6C>_rows)<02>selfr	s  <20>>E:\Project\pygoedge\.venv\Lib\site-packages\pymysql/cursors.py<70>__init__zCursor.__init__"sC<00><00>$<24><04><0F><1E><04><1A><1F><04><18><1A><04><0E><1A><04>
<0A><1A><04><0E><1D><04><0E><1B><04><0C><19><04>
<EFBFBD>c
<00><><00>|j}
|
<01>
y
	|j<00>r	|j<00>r
<01>d
|_y
#d
|_wxYw
)zD
        Closing a cursor just exhausts all remaining data.
        N)r	<00>nextset<65>r<00>conns  r<00>closezCursor.close-sB<00><00><14><EFBFBD><EFBFBD><04><0F><<3C><12>	#<23><16>,<2C>,<2C>.<2E><14><17>,<2C>,<2C>.<2E>#<23>D<EFBFBD>O<EFBFBD><4F>d<EFBFBD>D<EFBFBD>O<EFBFBD>s	<00>!;<00>	Ac

<00><00>|S<00>
N<><00>
rs
 r<00>	__enter__zCursor.__enter__:<00><00><00><13>rc
<00>&<00>~
|j
<00>
yr)
r)r<00>exc_infos  r<00>__exit__zCursor.__exit__=s<00><00><14><0C>
<EFBFBD>
<EFBFBD>rc
<00>\<00>|jstjd
<01>
<00>
|jS)Nz
Cursor closed)r	r<00>ProgrammingErrorrs
 r<00>_get_dbzCursor._get_dbAs$<00><00><13><EFBFBD><EFBFBD><15>&<26>&<26><EFBFBD>7<>7<><13><EFBFBD><EFBFBD>rc
<00>F<00>|jstjd
<01>
<00>
y)Nzexecute() first)rrr%rs
 r<00>_check_executedzCursor._check_executedFs <00><00><13>~<7E>~<7E><15>&<26>&<26>'8<>9<>9<>rc
<00><00>|
Srr<00>r<00>rows  r<00>	_conv_rowzCursor._conv_rowJ<00><00><00><12>
rc
<00><00>y
<01>z!Does nothing, required by DB API.Nr<00>r<00>argss  r<00>
setinputsizeszCursor.setinputsizesM<00><00>rc
<00><00>y
r/rr0s  r<00>setoutputsizeszCursor.setoutputsizesPr3rc<00><><00>|j
<00>}|j}|<03>||ju
r
y
|js
y
d
|_
|j<00>
|j	|
<01><02>

|j<00>
y)zGet the next query set.N<>
<01>
unbufferedT)r&r<00>has_next<78>
_clear_result<6C>next_result<6C>_do_get_result)rr8r<00>current_results    r<00>_nextsetzCursor._nextsetSsi<00><00><13>|<7C>|<7C>~<7E><04><1D><1C><1C><0E><19>!<21>^<5E>4<EFBFBD><<3C><<3C>%G<><17><1D>&<26>&<26><17><1B><04><0C><0C><1A><1A><1C><0C><18><18>J<EFBFBD><18>/<2F><0C><1B><1B><1D>rc
<00>$<00>|j
d
<01>
S)NF<4E>
r>rs
 rrzCursor.nextsetas<00><00><13>}<7D>}<7D>U<EFBFBD>#<23>#rc<00>
<00><02>t
|
ttf<02>rt<00>f
d
<01>|
D<00><00>
St
|
t<00>r3|
j	<00>D<00><03>cic]\}}|<03>j|<04>
<00><02>c}}S<00>j
|
<01>
Sc
c}}w)Nc
3<00>@<00>
K
<00>|]}
<01>j
|
<01>
<00>
<01>

<00>y<00>w
r)
<01>literal)<03>.0<EFBFBD>argrs  <20>r<00>	<genexpr>z&Cursor._escape_args.<locals>.<genexpr>fs<00><><00><><00>;<3B>d<EFBFBD>s<EFBFBD><14><1C><1C>c<EFBFBD>*<2A>d<EFBFBD>s<00>
)<07>
isinstance<EFBFBD>tuple<6C>list<73>dict<63>itemsrC<00>escape)rr1r<00>key<65>vals  `  r<00>_escape_argszCursor._escape_argsdsp<00><><00><15>d<EFBFBD>U<EFBFBD>D<EFBFBD>M<EFBFBD>*<2A><18>;<3B>d<EFBFBD>;<3B>;<3B>;<3B>
<17><04>d<EFBFBD>
#<23>=A<>Z<EFBFBD>Z<EFBFBD>\<5C>J<>\<5C>z<EFBFBD><03>S<EFBFBD>C<EFBFBD><14><1C><1C>c<EFBFBD>*<2A>*<2A>\<5C>J<>J<><18>;<3B>;<3B>t<EFBFBD>$<24>$<24><>	K
s<00>BNc<00>T<00>|j
<00>}|<02>|
|j||<03>z}
|
S)
a<>

        Returns the exact string that would be sent to the database by calling the
        execute() method.

        :param query: Query to mogrify.
        :type query: str

        :param args: Parameters used with query. (optional)
        :type args: tuple, list or dict

        :return: The query with argument binding applied.
        :rtype: str

        This method follows the extension to the DB API 2.0 followed by Psycopg.
        )r&rO)r<00>queryr1rs    r<00>mogrifyzCursor.mogrifyns1<00><00> <14>|<7C>|<7C>~<7E><04><0F><1B><19>D<EFBFBD>-<2D>-<2D>d<EFBFBD>D<EFBFBD>9<>9<>E<EFBFBD><14>rc<00><><00>|j
<00>r	|j
<00>r
<01>|j|
|<02>}
|j|
<01>
}|
|_|S)
a<>
Execute a query.

        :param query: Query to execute.
        :type query: str

        :param args: Parameters used with query. (optional)
        :type args: tuple, list or dict

        :return: Number of affected rows.
        :rtype: int

        If args is a list or tuple, %s can be used as a placeholder in the query.
        If args is a dict, %(name)s can be used as a placeholder in the query.
        )rrR<00>_queryr)rrQr1<00>results    r<00>executezCursor.execute<74>sG<00><00><13>l<EFBFBD>l<EFBFBD>n<EFBFBD><10><13>l<EFBFBD>l<EFBFBD>n<EFBFBD><15><0C><0C>U<EFBFBD>D<EFBFBD>)<29><05><15><1B><1B>U<EFBFBD>#<23><06><1E><04><0E><15>
rc	<00><>
<00><00>
<01>|s
y
tj<00>
<01>
}|r<>|jd<02>
dz}|jd<04>
j<00>}|jd<05>
x
s
d}|ddk(r|d	d
k(sJ<00>
<01>j	||||<02>j
<00>j
<00>j<00>St<00>
<01>fd<0B>|D<00><00>
<00>_	<00>jS)a<>
Run several data against one query.

        :param query: Query to execute.
        :type query: str

        :param args: Sequence of sequences or mappings. It is used as parameter.
        :type args: tuple or list

        :return: Number of rows affected, if any.
        :rtype: int or None

        This method improves performance on multiple-row INSERT and
        REPLACE. Otherwise it is equivalent to looping over args with
        execute().
        Nrr<00><00><00>r<00>
(r<00>
)c
3<00>B<00>K
<00>|]}
<01>j
<00>|
<01><00>
<01>

<00>y<00>w
r)
rV)rDrErQrs  <20><>rrFz%Cursor.executemany.<locals>.<genexpr><3E>s<00><><00><><00>E<><04><13>D<EFBFBD>L<EFBFBD>L<EFBFBD><15><03>4<><04>s<00>
)
<EFBFBD>RE_INSERT_VALUES<45>match<63>group<75>rstrip<69>_do_execute_many<6E>max_stmt_lengthr&<00>encoding<6E>sumr
)rrQr1<00>
m<>q_prefix<69>q_values<65>	q_postfixs``     r<00>executemanyzCursor.executemany<6E>s<><00><><00> <14><12><1C>"<22>"<22>5<EFBFBD>)<29>
<01><0C><18>w<EFBFBD>w<EFBFBD>q<EFBFBD>z<EFBFBD>B<EFBFBD><EFBFBD>H<EFBFBD><18>w<EFBFBD>w<EFBFBD>q<EFBFBD>z<EFBFBD>(<28>(<28>*<2A>H<EFBFBD><19><07><07>
<01>
<EFBFBD>(<28>b<EFBFBD>I<EFBFBD><1B>A<EFBFBD>;<3B>#<23>%<25>(<28>2<EFBFBD>,<2C>#<23>*=<3D>=<3D>=<3D><17>(<28>(<28><18><18><19><14><14>$<24>$<24><14><0C><0C><0E>'<27>'<27>
<0E>
<0E><1C>E<><04>E<>E<><04>
<0A><13>}<7D>}<7D>rc<00><><00>|j
<00>}|j}t|
t<00>r|
j	|<06>
}
t|t<00>r|j	|<06>
}t|
<01>
}	t
|<04>
}||t|<04>
|<07>z}
t|
t<00>r|
j	|d
<01>}
|	|
z
}	d}|D]<5D>}||||<07>z}
t|
t<00>r|
j	|d
<01>}
t|	<09>
t|
<EFBFBD>
zt|<03>
zdz|kDr#||j|	|z<00>
z
}t|
<01>
}	n|	dz
}	|	|
z
}	<09><>||j|	|z<00>
z
}||_
|S)N<>surrogateescaperr<00>
,)r&rOrG<00>str<74>encode<64>	bytearray<61>iter<65>next<78>lenrVr
)
r<00>prefix<69>values<65>postfixr1rcrdrrL<00>sql<71>
v<>rowsrEs
             rrbzCursor._do_execute_many<6E>sL
<00><00><14>|<7C>|<7C>~<7E><04><15>"<22>"<22><06><15>f<EFBFBD>c<EFBFBD>"<22><1B>]<5D>]<5D>8<EFBFBD>,<2C>F<EFBFBD><15>g<EFBFBD>s<EFBFBD>#<23><1D>n<EFBFBD>n<EFBFBD>X<EFBFBD>.<2E>G<EFBFBD><17><06><1F><03><13>D<EFBFBD>z<EFBFBD><04><12>V<EFBFBD>D<EFBFBD><14>J<EFBFBD><04>-<2D>-<2D>
<01><15>a<EFBFBD><13><1D><11><08><08><18>#4<>5<>A<EFBFBD><0B>q<EFBFBD><08><03><10><04><17>C<EFBFBD><16><16><03>T<EFBFBD>*<2A>*<2A>A<EFBFBD><19>!<21>S<EFBFBD>!<21><15>H<EFBFBD>H<EFBFBD>X<EFBFBD>'8<>9<>
<01><12>3<EFBFBD>x<EFBFBD>#<23>a<EFBFBD>&<26> <20>3<EFBFBD>w<EFBFBD><<3C>/<2F>!<21>3<>o<EFBFBD>E<><14><04><0C><0C>S<EFBFBD>7<EFBFBD>]<5D>3<>3<><04><1F><06>'<27><03><13>t<EFBFBD><0B><03><0F>1<EFBFBD>H<EFBFBD>C<EFBFBD><18>	
<0A><04><0C><0C>S<EFBFBD>7<EFBFBD>]<5D>+<2B>+<2B><04><1C><04>
<0A><13>rc<00><>
<00><05><06>|j
<00><00>|rLd
|
<01>d<02><03>|jddj<00><05>fd<05>t|<02>
D<00><00>
z<00>

|j	<00>
dj|
djt
t|<02>
<00>
D<00>cgc]	}d|
|fz<00><02>c}<03>
<00>}|j|<04>

||_|Sc
c}w)abExecute stored procedure procname with args.

        :param procname: Name of procedure to execute on server.
        :type procname: str

        :param args: Sequence of parameters to use with procedure.
        :type args: tuple or list

        Returns the original args.

        Compatibility warning: PEP-249 specifies that any modified
        parameters must be returned. This is currently impossible
        as they are only available by storing them in a server
        variable and then retrieved by a query. Since stored
        procedures return zero or more result sets, there is no
        reliable way to get at OUT or INOUT parameters via callproc.
        The server variables are named @_procname_n, where procname
        is the parameter above and n is the position of the parameter
        (from zero). Once all result sets generated by the procedure
        have been fetched, you can issue a SELECT @_procname_0, ...
        query using .execute() to get any OUT or INOUT values.

        Compatibility warning: The act of calling a stored procedure
        itself creates an empty result set. This appears after any
        result sets generated by the procedure. This is non-standard
        behavior with respect to the DB-API. Be sure to use nextset()
        to advance through all result sets; otherwise you may get
        disconnected.
        z@_z_%d=%szSET %s<>
,c
3<00>P<00>K
<00>|]\}
}<02>|
<01>j
|<02>
fz<00>
<01>

<00>y<00>w
r)
rL)rD<00>indexrEr<00>fmts   <20><>rrFz"Cursor.callproc.<locals>.<genexpr>
s,<00><><00><><00><12>FU<46>
<EFBFBD><05>s<EFBFBD>C<EFBFBD>5<EFBFBD>$<24>+<2B>+<2B>c<EFBFBD>"2<>3<>3<>o<EFBFBD>s<00>#&
zCALL {}({})z@_%s_%d)	r&rT<00>join<69>	enumerater<00>format<61>rangersr)r<00>procnamer1<00>
i<>
qrr~s     @@r<00>callproczCursor.callproc<6F>s<><00><><00><<14>|<7C>|<7C>~<7E><04><0F><16>x<EFBFBD>j<EFBFBD><06>'<27>C<EFBFBD><10>K<EFBFBD>K<EFBFBD><18><15>(<28>(<28><12>FO<46>PT<50>o<EFBFBD><12><12><12>
<0E>
<11>L<EFBFBD>L<EFBFBD>N<EFBFBD><19> <20> <20><14><0F>H<EFBFBD>H<EFBFBD><15>s<EFBFBD>4<EFBFBD>y<EFBFBD>9I<39>J<>9I<39>A<EFBFBD>i<EFBFBD>8<EFBFBD>Q<EFBFBD>-<2D>/<2F>9I<39>J<>K<>
<EFBFBD>
<01>	
<0A><0B><0B>A<EFBFBD><0E><1A><04><0E><13><0B><>	K
s<00>C
c
<00><><00>|j
<00>
|j<00>"|jt|j<00>
k\r
y
|j|j}
|x
jdz
c_|
S)zFetch the next row.Nr<00>r(rrrs<00>rrUs  r<00>fetchonezCursor.fetchone
sS<00><00><0C><1C><1C><1E><0F>:<3A>:<3A><1D><14><1E><1E>3<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>?<3F>!B<><17><15><1A><1A>D<EFBFBD>N<EFBFBD>N<EFBFBD>+<2B><06><0C><0E><0E>!<21><1B><0E><15>
rc<00><><00>|j
<00>
|j<00>
y
|j|
x
s
|jz}|j|j|}t	|t|j<00>
<00>|_|S)zFetch several rows.r)r(rrr<00>minrs)r<00>size<7A>endrUs    r<00>	fetchmanyzCursor.fetchmany
sc<00><00><0C><1C><1C><1E><0F>:<3A>:<3A><1D><16><12>n<EFBFBD>n<EFBFBD><04> 6<><04><0E><0E>7<><03><15><1A><1A>D<EFBFBD>N<EFBFBD>N<EFBFBD>S<EFBFBD>1<><06><1C>S<EFBFBD>#<23>d<EFBFBD>j<EFBFBD>j<EFBFBD>/<2F>2<><04><0E><15>
rc
<00><><00>|j
<00>
|j<00>gS|jr|j|jd
}
n|j}
t|j<00>
|_|
S)zFetch all the rows.Nr<4E>r<>s  r<00>fetchallzCursor.fetchall&
sV<00><00><0C><1C><1C><1E><0F>:<3A>:<3A><1D><15>I<EFBFBD><0F>><3E>><3E><19>Z<EFBFBD>Z<EFBFBD><04><0E><0E> 0<>1<>F<EFBFBD><19>Z<EFBFBD>Z<EFBFBD>F<EFBFBD><1C>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><1F><04><0E><15>
rc<00>
<00>|j
<00>
|d
k(r|j|
z}n |dk(r|
}ntjd|z<00>
<00>
d|cxkr"t	|j
<00>
kst
d<05>
<00>

t
d<05>
<00>
||_
y)N<>relative<76>absolute<74>unknown scroll mode %srzout of range)r(rrr%rsr<00>
IndexError)r<00>value<75>mode<64>
rs    r<00>scrollz
Cursor.scroll2
s<00><00><0C><1C><1C><1E><0F>:<3A><1D><14><0E><0E><15>&<26>A<EFBFBD>
<11>Z<EFBFBD>
<1F><15>A<EFBFBD><15>&<26>&<26>'?<3F>$<24>'F<>G<>G<><11>Q<EFBFBD>(<28><13>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><1F>(<28><1C>^<5E>,<2C>,<2C>)<29><1C>^<5E>,<2C>,<2C><1A><04>rc<00><><00>|j
<00>}|j<00>
|j|
<01>

|j<00>
|jSr<00>r&r:rQr<r
<00>rr<>rs   rrTz
Cursor._query?
s:<00><00><13>|<7C>|<7C>~<7E><04><0C><1A><1A><1C><0C>
<EFBFBD>
<EFBFBD>1<EFBFBD>
<0A><0C><1B><1B><1D><13>}<7D>}<7D>rc
<00>f<00>d
|_d|_
d
|_d
|_d|_d|_d|_y)Nr)rrr
r
r<00>	lastrowidrrs
 rr:zCursor._clear_resultF
s5<00><00><1A><04><0E><1B><04><0C><19><04>
<0A><1E><04><1A><1F><04><18><1D><04><0E><19><04>
rc
<00><><00>|j
<00>}
|
jx
|_
}|j|_|j|_|j
|_|j|_|j|_	yr)
r&r<00>
affected_rowsr
r
r<00>	insert_idr<64>ryr)rrrUs   rr<zCursor._do_get_resultP
s^<00><00><13>|<7C>|<7C>~<7E><04> $<24><0C><0C>,<2C><04><0C>v<EFBFBD><1E>,<2C>,<2C><04>
<0A>#<23>1<>1<><04><1A>!<21>-<2D>-<2D><04><18><1F>)<29>)<29><04><0E><1B>[<5B>[<5B><04>
rc

<00><00>|Srrrs
 r<00>__iter__zCursor.__iter__[
r rc
<00>6<00>|j
<00>}
|
<01>t<00>
|
Sr)r<><00>
StopIterationr*s  r<00>__next__zCursor.__next__^
s<00><00><12>m<EFBFBD>m<EFBFBD>o<EFBFBD><03><0E>;<3B><1F><1F><12>
rc<00>x<00>|
d
vr,t
jdtd<03><04>
tt|
<01>St|
<01>
<00>
)N)
<EFBFBD>Warning<6E>Error<6F>InterfaceError<6F>
DatabaseError<6F>	DataError<6F>OperationalError<6F>IntegrityError<6F>
InternalErrorr%<00>NotSupportedErrorz7PyMySQL errors hould be accessed from `pymysql` packagerX)
<01>
stacklevel)<06>warnings<67>warn<72>DeprecationWarning<6E>getattrr<00>AttributeError)r<00>names  r<00>__getattr__zCursor.__getattr__d
sB<00><00><10>
<EFBFBD>
<EFBFBD>
<15>M<EFBFBD>M<EFBFBD>I<>"<22><1C>
<0E>
<1B>3<EFBFBD><04>%<25>%<25><1C>T<EFBFBD>"<22>"r)
Fr)
r<00>
r<>) <20>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__rcrrrr#r&r(r,r2r5r>rrOrRrVrjrbr<>r<>r<>r<>r<>rTr:r<r<>r<>r<>rrrrrs<><00><00><08><1E>O<EFBFBD>	<1A>#<23>
<14><15><1F>
:<3A>
<13>
0<>
0<><14>
$<24>%<25><15>.<16>0#<1D>J
<14></<14>b
<16>
<16>
<16><1B><1D><1A>	!<21>
<14><13>#rrc<00>(<00><00>eZ
dZeZ<04>f
d
<01>Zd<02>Z<06>x
ZS)<03>DictCursorMixinc
<00>n
<00>
<01>t<00>|<00><00>
g}
|jrU|jjD]5}|j
}||
vr|jd
z|z}|
j|<03>

<00>7|
|_|
r<|jr/|jD<00>cgc]}|j|<04>
<00><02>c}|_	yyyc
c}w)N<>
.)<0B>superr<rr<00>fieldsr<73><00>
table_name<EFBFBD>append<6E>_fieldsrr,)rr<><00>
fr<66>r<><00>	__class__s     <20>rr<zDictCursorMixin._do_get_result<6C>
s<><00><><00>
<0A><07><1E> <20><13><06><0F><1B><1B><19>\<5C>\<5C>(<28>(<28>
<01><18>v<EFBFBD>v<EFBFBD><04><17>6<EFBFBD>><3E><1C><<3C><<3C>#<23>-<2D><04>4<>D<EFBFBD><16>
<0A>
<0A>d<EFBFBD>#<23>	)<29>
"<22>D<EFBFBD>L<EFBFBD><11>d<EFBFBD>j<EFBFBD>j<EFBFBD>59<35>Z<EFBFBD>Z<EFBFBD>@<40>Z<EFBFBD>
<01>$<24>.<2E>.<2E><11>+<2B>Z<EFBFBD>@<40>D<EFBFBD>J<EFBFBD>!<21>6<EFBFBD><36>@s<00>B2c<00>R<00>|
<01>
y|j
t|j|
<01><00>
Sr)<03>	dict_type<70>zipr<70>r*s  rr,zDictCursorMixin._conv_row<6F>
s$<00><00><0E>;<3B><17><13>~<7E>~<7E>c<EFBFBD>$<24>,<2C>,<2C><03>4<>5<>5r)r<>r<>r<>rJr<>r<r,<00>
__classcell__)
r<>s
@rr<>r<>}
s<00><><00><14>I<EFBFBD>A
<01>6rr<>c
<00><00>eZ
dZd
Zy)<03>
DictCursorz.A cursor which returns results as a dictionaryN<79>r<>r<>r<>r<>rrrr<>r<><00>
s<00><00>8rr<>c<00>T<00>eZ
dZd
Zd<02>Zd<03>ZeZd<04>Zd<05>Zd<06>Z	d<07>Z
d<08>Zd	<09>Zd
d<0B>
Z
dd<0C>
Zy
)<0F>SSCursora<72>
    Unbuffered Cursor, mainly useful for queries that return a lot of data,
    or for connections to remote servers over a slow network.

    Instead of copying every row of data into a buffer, this will fetch
    rows as needed. The upside of this is the client uses much less memory,
    and rows are returned much faster when traveling over a slow network
    or if the result set is very big.

    There are limitations, though. The MySQL protocol doesn't support
    returning the total number of rows, so the only way to tell how many rows
    there are is to iterate over every row returned. Also, it currently isn't
    possible to scroll backwards, as only the current row is held in memory.
    c
<00><00>|
Srrr*s  rr,zSSCursor._conv_row<6F>
r-rc
<00>

<00>|j}
|
<01>
y|j<00>2|j|
jur|jj<00>
	|j<00>r	|j<00>r
<01>d|_y#d|_wxYw
r)r	r<00>_finish_unbuffered_queryrrs  rrzSSCursor.close<73>
si<00><00><13><EFBFBD><EFBFBD><04><0F><<3C><12><0F><<3C><<3C>#<23><04><0C><0C><04><0C><0C>(D<><10>L<EFBFBD>L<EFBFBD>1<>1<>3<>	#<23><16>,<2C>,<2C>.<2E><14><17>,<2C>,<2C>.<2E>#<23>D<EFBFBD>O<EFBFBD><4F>d<EFBFBD>D<EFBFBD>O<EFBFBD>s<00>!A9<00>9	Bc<00><><00>|j
<00>}|j<00>
|j|
d
<01><02>
|j<00>
|jS<00>NTr7r<>r<>s   rrTzSSCursor._query<72>
s?<00><00><13>|<7C>|<7C>~<7E><04><0C><1A><1A><1C><0C>
<EFBFBD>
<EFBFBD>1<EFBFBD><14>
<EFBFBD>&<26><0C><1B><1B><1D><13>}<7D>}<7D>rc
<00>&<00>|j
d
<01><02>
Sr<>r@rs
 rrzSSCursor.nextset<65>
s<00><00><13>}<7D>}<7D><04>}<7D>-<2D>-rc
<00>T<00>|j
|jj<00><00>
S)
zRead next row.)r,r<00>_read_rowdata_packet_unbufferedrs
 r<00>	read_nextzSSCursor.read_next<78>
s<00><00><13>~<7E>~<7E>d<EFBFBD>l<EFBFBD>l<EFBFBD>J<>J<>L<>M<>Mrc
<00><><00>|j
<00>
|j<00>}
|
<01>|jj|_y
|x
jdz
c_|
S)zFetch next row.Nr)r(r<>rr
rr*s  rr<>zSSCursor.fetchone<6E>
sG<00><00><0C><1C><1C><1E><12>n<EFBFBD>n<EFBFBD><1E><03><0E>;<3B>!%<25><1C><1C>!;<3B>!;<3B>D<EFBFBD><1E><17><0C><0E><0E>!<21><1B><0E><12>
rc
<00>4<00>t
|j<00><00>
S)
z<>
        Fetch all, as per MySQLdb. Pretty useless for large queries, as
        it is buffered. See fetchall_unbuffered(), if you want an unbuffered
        generator version of this method.
        )rI<00>fetchall_unbufferedrs
 rr<>zSSCursor.fetchall<6C>
s<00><00><14>D<EFBFBD>,<2C>,<2C>.<2E>/<2F>/rc
<00>.<00>t
|jd
<01>S)z<>
        Fetch all, implemented as a generator, which isn't to standard,
        however, it doesn't make sense to return everything in a list, as that
        would use ridiculous memory for large result sets.
        N)rqr<>rs
 rr<>zSSCursor.fetchall_unbuffered<65>
s<00><00><14>D<EFBFBD>M<EFBFBD>M<EFBFBD>4<EFBFBD>(<28>(rNc<00>
<00>|j
<00>
|
<01>|j}
g}t|
<01>
D]W}|j<00>}|<04>|jj
|_
n(|j
|<04>

|x
jd
z
c_<00>Y|s
y|S)zFetch many.rr)r(rr<>r<>rr
r<>r)rr<>ryr<>r+s     rr<>zSSCursor.fetchmany<6E>
s~<00><00><0C><1C><1C><1E><0F><<3C><17>><3E>><3E>D<EFBFBD><11><04><16>t<EFBFBD><1B>A<EFBFBD><16>.<2E>.<2E>"<22>C<EFBFBD><12>{<7B>%)<29>\<5C>\<5C>%?<3F>%?<3F><04>"<22><15><10>K<EFBFBD>K<EFBFBD><03><1C><10>N<EFBFBD>N<EFBFBD>a<EFBFBD><1F>N<EFBFBD>
<1D><14><16><13>rc<00><>
<00>|j
<00>
|d
k(rP|
dkrtjd<03>
<00>
t|
<01>
D]}|j	<00>
<00>|x
j
|
z
c_y|dk(r[|
|j
krtjd<03>
<00>
|
|j
z
}t|<04>
D]}|j	<00>
<00>|
|_ytjd|z<00>
<00>
)Nr<4E>rz0Backwards scrolling not supported by this cursorr<72>r<>)r(rr<>r<>r<>rr%)rr<>r<><00>
_r<5F>s     rr<>zSSCursor.scroll<6C>
s<><00><00><0C><1C><1C><1E><0F>:<3A><1D><14>q<EFBFBD>y<EFBFBD><19>+<2B>+<2B>F<><12><12><1B>5<EFBFBD>\<5C>
<01><14><0E><0E> <20>"<22><10>N<EFBFBD>N<EFBFBD>e<EFBFBD>#<23>N<EFBFBD>
<11>Z<EFBFBD>
<1F><14>t<EFBFBD>~<7E>~<7E>%<25><19>+<2B>+<2B>F<><12><12><18>$<24>.<2E>.<2E>(<28>C<EFBFBD><1A>3<EFBFBD>Z<EFBFBD>
<01><14><0E><0E> <20> <20>"<22>D<EFBFBD>N<EFBFBD><15>&<26>&<26>'?<3F>$<24>'F<>G<>Grrr<>)r<>r<>r<>r<>r,r<00>__del__rTrr<>r<>r<>r<>r<>r<>rrrr<>r<><00>
sB<00><00>
<08>
<13>#<23><14>G<EFBFBD><1D>
.<2E>N
<01><13>0<>)<29><14>(H
rr<>c
<00><00>eZ
dZd
Zy)<03>SSDictCursorz;An unbuffered cursor, which returns results as a dictionaryNr<4E>rrrr<>r<>s<00><00>Err<>)
<0A>rer<65>rZr<00>compile<6C>
IGNORECASE<EFBFBD>DOTALLr^rr<>r<>r<>r<>rrr<00><module>r<>
s~<00>


<01>	<09><0F><11><1E>2<EFBFBD>:<3A>:<3A>)<29><07>M<EFBFBD>M<EFBFBD>B<EFBFBD>I<EFBFBD>I<EFBFBD><1D>	<02><10>i
#<23>i
#<23>X
6<>
6<>0

9<><1F>&<26>

9<>v

H
<01>v<EFBFBD>v

H
<01>r

F
<01>?<3F>H<EFBFBD>

F
r