/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine
Edit: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyc (50588B)
4]c @ s d Z d d l Z d d l Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z y d d l
m Z d Z Wn e
k
r d
Z n Xy d d l
m Z e Z Wn- e
k
r e Z d e f d
YZ n Xd e f d YZ y e j j j e Wn e
k
r2n Xd e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d S( sS Define result set constructs including :class:`.ResultProxy`
and :class:`.RowProxy.iNi ( t exc( t util( t
expression( t sqltypes( t safe_rowproxy_reconstructorc C s
t | | S( N( R ( t clst state( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt rowproxy_reconstructor! s c C s | j | } | j | | S( N( t __new__t __setstate__( R R t obj( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR ' s
( t BaseRowProxyR c B sM e Z d Z d Z d Z d Z d Z d Z d Z d
Z RS( t _parentt _rowt _processorst _keymapc C s( | | _ | | _ | | _ | | _ d S( s8 RowProxy objects are constructed by ResultProxy objects.N( R R
R R ( t selft parentt rowt
processorst keymap( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __init__7 s c C s t | j | j f f S( N( R t __class__t __getstate__( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt
__reduce__? s c C s
t | S( s9 Return the values represented by this RowProxy as a list.( t list( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt valuesE s c c sI xB t | j | j D]+ \ } } | d k r6 | Vq | | Vq Wd S( N( t zipR R
t None( R t processort value( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __iter__I s " c C s
t | j S( N( t lenR
( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __len__P s c C s& y | j | \ } } } Wn t k
rH | j j | \ } } } n t k
r t | t r g } xZ t | j | | j | D]; \ } } | d k r | j | q | j | | q Wt | S n X| d k r t
j d | n | d k r| | j | S| j | Sd S( Ns< Ambiguous column name '%s' in result set column descriptions( R t KeyErrorR t
_key_fallbackt TypeErrort
isinstancet sliceR R R
R t appendt tupleR t InvalidRequestError( R t keyR R
t indext lR ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __getitem__S s*
$
c C s9 y | | SWn& t k
r4 } t | j d n Xd S( Ni ( R" t AttributeErrort args( R t namet e( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __getattr__o s ( R R
R R (
t __name__t
__module__t __slots__R R R R R! R- R2 ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR 4 s t RowProxyc B s e Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d Z d Z
d Z d
Z d Z d Z d
Z d Z d Z d Z RS( sx Proxy values from a single cursor row.
Mostly follows "ordered dictionary" behavior, mapping result
values to the string-based column name, the integer position of
the result in the row, as well as Column instances which can be
mapped to the original Columns that produced this result set (for
results that correspond to constructed SQL expressions).
c C s | j j | S( N( R t _has_key( R R* ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __contains__ s c C s i | j d 6t | d 6S( NR R
( R R( ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c C s: | d | _ } | d | _ | j | _ | j | _ d S( NR R
( R R
R R ( R R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s; t | t r( | t | t | S| t | | S( N( R% R6 R( ( R t othert op( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _op s (c C s | j | t j S( N( R; t operatort lt( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __lt__ s c C s | j | t j S( N( R; R< t le( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __le__ s c C s | j | t j S( N( R; R< t ge( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __ge__ s c C s | j | t j S( N( R; R< t gt( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __gt__ s c C s | j | t j S( N( R; R< t eq( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __eq__ s c C s | j | t j S( N( R; R< t ne( R R9 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __ne__ s c C s t t j | S( N( t reprt sql_utilt _repr_row( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __repr__ s c C s | j j | S( s4 Return True if this RowProxy contains the given key.( R R7 ( R R* ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt has_key s c C s' g | j D] } | | | f ^ q
S( s@ Return a list of tuples, each tuple containing a key/value pair.( t keys( R R* ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt items s c C s
| j j S( s@ Return the list of keys as strings represented by this RowProxy.( R RN ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyRN s c C s t | j j S( N( t iterR RN ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt iterkeys s c C s
t | S( N( RP ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt
itervalues s ( N( R3 R4 t __doc__R5 R8 R R R t __hash__R; R> R@ RB RD RF RH RL RM RO RN RQ RR ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR6 v s& t ResultMetaDatac B s e Z d Z d Z d Z d Z d Z d
Z d Z d Z e
e d
Z e d Z
d Z e d Z d Z d Z RS( sR Handle cursor.description, applying additional info from an execution
context.R t case_sensitivet matched_on_nameR RN t _orig_processorsc C sx | j } | j } | j | _ t | _ d | _ | j rZ | j \ } } } t | } n t } } } } | j | | | | | | } i | _
t s$t | }
| j
j g | D]+ } | d | d | d | d f f ^ q g | D]/ } | d |
| d | d | d f f ^ q n g | D] } | d ^ q+| _
t g | D]+ } | d | d | d | d f f ^ qN } | rt | | k rt }
xb | D]Z } | d } | |
k r| j s| j n | } d | d f | |
>
,
@
< c
C sW | j j } | r | r | r | t | k r g | D] } | d ^ q8 | _ g t | D]Y \ } \ }
} } }
| |
| s | j n | | j |
|
| | d | d f ^ q^ S| r | j | | | } n0 | r | j | | | } n | j
| | } g | D]? \ } } } } } } | | | | j | | | | | f ^ qSd S( s 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:`.TextAsFrom` 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:`.TextAsFrom` 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.
i i N( RZ RV R RN t enumerateRb t get_result_processorR t _merge_textual_cols_by_positiont _merge_cols_by_namet _merge_cols_by_none( R RY Re Rf Ri Rg Rh RV Rl t idxR* R0 R
t type_t raw_iteratort colnamet mapped_typet coltypet untranslated( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR] N s$ >
g c
c s
| j } | j } | j } | j r- | j n d } | j rE | j n d } d } g | _ x t | D] \ } }
|
d } |
d } | r | | } n | r | | \ } } n | r | | } n | j j
| | s | j } n | | | | f Vqg Wd S( s Extract 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.
i i N( RZ RV Rd t description_encodingt _description_decoderR t requires_name_normalizet normalize_nameRN Rq R' Rb (
R RY Re RZ RV t translate_colnamet description_decoderR R| Rv Ro Ry R{ ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _colnames_from_description s*
c
c s | r t | n d } | t | k rJ t j d | t | f n t } x | j | | D] \ } } } } | | k r | | }
|
d } |
d } | d | k r t j d | d n | j | d n t j
} d } | | | | | | f Vqf Wd S( NsV Number of columns in textual SQL (%d) is smaller than number of columns requested (%d)i i i s8 Duplicate column expression requested in textual SQL: %r( R R R t warnRa R R R) Rc R t NULLTYPE(
R RY Re Rf Ri Rn Rv Ry R| R{ t ctx_recR
Rz ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyRs s( "
c c s | j } | j } | j | | } t | _ x | j | | D]n \ } } } }
y | | } Wn t k
r t j } d }
n X| d }
| d } | | | |
|
| f Vq@ Wd S( Ni i (
RZ RV t _create_result_mapt TrueRW R R" R R R ( R RY Re Rf RZ RV t
result_mapRv Ry R| R{ R Rz R
( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyRt s "
c c sG x@ | j | | D], \ } } } } | | t j | d | f Vq Wd S( N( R R R R ( R RY Re Rv Ry R| R{ ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyRu / s "c
C s i } x | D]w } | d | d } } | s= | j } n | | k rz | | \ } } } | | | d | f | | s t _pickled_keymapRN RV RW ( R` R RO RN RV RW ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s g t t | d D] } d ^ q | _ i | _ } x1 | d j D] \ } } d d | f | | s (
t _cursor_descriptionR RY t compiledt execution_optionst _cached_metadataR RU R R t loggert debugR( ( R Re ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s " c C s | j r | j j Sg Sd S( s/ Return the current set of string keys for rows.N( R RN ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyRN s
c C sJ y | j j SWn5 t k
rE } | j j | d d | j | j n Xd S( s Return 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:`.ResultProxy.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:`.ResultProxy.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:`.ResultProxy.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:`.ResultProxy.supports_sane_rowcount` and
:meth:`.ResultProxy.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.
N( RY t rowcountt
BaseExceptionR t _handle_dbapi_exceptionR R ( R R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
) c C sJ y | j j SWn5 t k
rE } | j j | d d | j | j n Xd S( s/ return 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:`~ResultProxy.inserted_primary_key` attribute provides a
tuple of primary key values for a newly inserted row,
regardless of database backend.
N( R t lastrowidR R R R RY ( R R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR - s
c C s
| j d k S( s True if this :class:`.ResultProxy` returns rows.
I.e. if it is legal to call the methods
:meth:`~.ResultProxy.fetchone`,
:meth:`~.ResultProxy.fetchmany`
:meth:`~.ResultProxy.fetchall`.
N( R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt returns_rowsD s
c C s
| j j S( sd True if this :class:`.ResultProxy` 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.
( RY t isinsert( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt is_insertP s c C s
| j j S( s May be overridden by subclasses.( R t description( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR ^ s c C sU | j r
d St | _ | j } | j j | | j rH | j j n d | _ d S( sl Soft close this :class:`.ResultProxy`.
This releases all DBAPI cursor resources, but leaves the
ResultProxy "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:`.ResultProxy.close`
N( t _soft_closedR R R t _safe_close_cursort _autoclose_connectiont closeR ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _soft_closec s c C s# | j s | j t | _ n d S( s Close this ResultProxy.
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:`.ResultProxy`
exhausts all available rows. :meth:`.ResultProxy.close` is generally
an optional method except in the case when discarding a
:class:`.ResultProxy` that still has additional rows pending for fetch.
In the case of a result that is the product of
:ref:`connectionless execution `,
the underlying :class:`.Connection` object is also closed, which
:term:`releases` DBAPI connection resources.
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.
.. versionchanged:: 1.0.0 - the :meth:`.ResultProxy.close` method
has been separated out from the process that releases the underlying
DBAPI cursor resource. The "auto close" feature of the
:class:`.Connection` now performs a so-called "soft close", which
releases the underlying DBAPI cursor, but allows the
:class:`.ResultProxy` to still behave as an open-but-exhausted
result set; the actual :meth:`.ResultProxy.close` method is never
called. It is still safe to discard a :class:`.ResultProxy`
that has been fully exhausted without calling this method.
.. seealso::
:ref:`connections_toplevel`
:meth:`.ResultProxy._soft_close`
N( t closedR R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s %
c c s2 x+ t r- | j } | d k r% d S| Vq Wd S( s Implement iteration protocol.N( R t fetchoneR ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s, | j } | d k r$ t n | Sd S( sG Implement the next() protocol.
.. versionadded:: 1.2
N( R R t
StopIteration( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt __next__ s c C sd | j j s t j d n< | j j s< t j d n | j j rZ t j d n | j j S( s Return the primary key for the row just inserted.
The return value is a list of scalar values
corresponding to the list of primary key columns
in the target table.
This only applies to single row :func:`.insert`
constructs which did not explicitly specify
:meth:`.Insert.returning`.
Note that primary key columns which specify a
server_default clause,
or otherwise do not qualify as "autoincrement"
columns (see the notes at :class:`.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.
s1 Statement is not a compiled expression construct.s2 Statement is not an insert() expression construct.s9 Can't call inserted_primary_key when returning() is used.( RY R R R) R t _is_explicit_returningt inserted_primary_key( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c C sd | j j s t j d nB | j j s< t j d n$ | j j rR | j j S| j j d Sd S( s Return 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.
s1 Statement is not a compiled expression construct.s2 Statement is not an update() expression construct.i N( RY R R R) t isupdatet executemanyt compiled_parameters( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt last_updated_params s
c C sd | j j s t j d nB | j j s< t j d n$ | j j rR | j j S| j j d Sd S( s Return 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.
s1 Statement is not a compiled expression construct.s2 Statement is not an insert() expression construct.i N( RY R R R) R R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt last_inserted_params s
c C s
| j j S( s Return the values of default columns that were fetched using
the :meth:`.ValuesBase.return_defaults` feature.
The value is an instance of :class:`.RowProxy`, 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`
( RY t returned_defaults( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c C s
| j j S( s Return ``lastrow_has_defaults()`` from the underlying
:class:`.ExecutionContext`.
See :class:`.ExecutionContext` for details.
( RY t lastrow_has_defaults( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR . s c C sT | j j s t j d n, | j j rJ | j j rJ t j d n | j j S( sM Return ``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.
s1 Statement is not a compiled expression construct.s> Statement is not an insert() or update() expression construct.( RY R R R) R R t postfetch_cols( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR 8 s c C sT | j j s t j d n, | j j rJ | j j rJ t j d n | j j S( sL Return ``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.
s1 Statement is not a compiled expression construct.s> Statement is not an insert() or update() expression construct.( RY R R R) R R t
prefetch_cols( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR O s c C s
| j j S( sx Return ``supports_sane_rowcount`` from the dialect.
See :attr:`.ResultProxy.rowcount` for background.
( RZ t supports_sane_rowcount( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR f s c C s
| j j S( s~ Return ``supports_sane_multi_rowcount`` from the dialect.
See :attr:`.ResultProxy.rowcount` for background.
( RZ t supports_sane_multi_rowcount( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR o s c C s3 y | j j SWn t k
r. | j d SXd S( N( R R R. R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _fetchone_implx s
c C sO y- | d k r | j j S| j j | SWn t k
rJ | j g SXd S( N( R R t fetchmanyR. R ( R t size( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _fetchmany_impl~ s
c C s3 y | j j SWn t k
r. | j g SXd S( N( R t fetchallR. R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt _fetchall_impl s
c C sD | j d k r! t j d n | j r< t j d n | Sd S( NsJ This result object does not return rows. It has been closed automatically.s This result object is closed.( R R R t ResourceClosedErrorR ( R t default( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c C s | j } | j } | j } | j } | j r | j j j j } g } x@ | D]8 } | d t j
| | j | | | | | qL W| Sg | D] } | | | | | ^ q Sd S( Ns Row %r( t _process_rowR R R R RY R R R RJ RK R' ( R t rowst process_rowt metadataR R t logR, R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt process_rows s
c C sc y' | j | j } | j | SWn5 t k
r^ } | j j | d d | j | j n Xd S( sv Fetch all rows, just like DB-API ``cursor.fetchall()``.
After all rows have been exhausted, the underlying DBAPI
cursor resource is released, and the object may be safely
discarded.
Subsequent calls to :meth:`.ResultProxy.fetchall` will return
an empty list. After the :meth:`.ResultProxy.close` method is
called, the method will raise :class:`.ResourceClosedError`.
.. versionchanged:: 1.0.0 - Added "soft close" behavior which
allows the result to be used in an "exhausted" state prior to
calling the :meth:`.ResultProxy.close` method.
N( R R R R R R R R RY ( R R, R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s{ y? | j | j | } t | d k r: | j n | SWn5 t k
rv } | j j | d d | j | j n Xd S( s Fetch many rows, just like DB-API
``cursor.fetchmany(size=cursor.arraysize)``.
After all rows have been exhausted, the underlying DBAPI
cursor resource is released, and the object may be safely
discarded.
Calls to :meth:`.ResultProxy.fetchmany` after all rows have been
exhausted will return
an empty list. After the :meth:`.ResultProxy.close` method is
called, the method will raise :class:`.ResourceClosedError`.
.. versionchanged:: 1.0.0 - Added "soft close" behavior which
allows the result to be used in an "exhausted" state prior to
calling the :meth:`.ResultProxy.close` method.
i N(
R R R R R R R R R RY ( R R R, R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C sz y> | j } | d k r/ | j | g d S| j d SWn5 t k
ru } | j j | d d | j | j n Xd S( s Fetch one row, just like DB-API ``cursor.fetchone()``.
After all rows have been exhausted, the underlying DBAPI
cursor resource is released, and the object may be safely
discarded.
Calls to :meth:`.ResultProxy.fetchone` after all rows have
been exhausted will return ``None``.
After the :meth:`.ResultProxy.close` method is
called, the method will raise :class:`.ResourceClosedError`.
.. versionchanged:: 1.0.0 - Added "soft close" behavior which
allows the result to be used in an "exhausted" state prior to
calling the :meth:`.ResultProxy.close` method.
i N( R R R R R R R R RY ( R R R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s | j d k r | j d Sy | j } Wn5 t k
rc } | j j | d d | j | j n Xz( | d k r | j | g d Sd SWd | j
Xd S( s Fetch the first row and then close the result set unconditionally.
Returns None if no row is present.
After calling this method, the object is fully closed,
e.g. the :meth:`.ResultProxy.close` method will have been called.
i N( R R R R R R R R RY R R ( R R R1 ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt first s
c C s( | j } | d k r | d Sd Sd S( s Fetch the first column of the first row, and close the result set.
Returns None if no row is present.
After calling this method, the object is fully closed,
e.g. the :meth:`.ResultProxy.close` method will have been called.
i N( R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt scalar s N(2 R3 R4 RS R6 R R t out_parametersR[ R R R R R R R R7 R RN R t memoized_propertyR t propertyR R R R R R R R t nextR R R R R R R R R R R R R R R R R R R ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR sR
0 )
,
t BufferedRowResultProxyc B s e Z d Z d Z i d d 6d d 6d d 6d d 6d d 6d d 6d d 6d
d 6Z d Z d Z d
Z d d Z d Z
RS( s A ResultProxy with row buffering behavior.
``ResultProxy`` that 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 to a size of 1000.
The size argument is configurable using the ``max_row_buffer``
execution option::
with psycopg2_engine.connect() as conn:
result = conn.execution_options(
stream_results=True, max_row_buffer=50
).execute("select * from table")
.. versionadded:: 1.0.6 Added the ``max_row_buffer`` option.
.. seealso::
:ref:`psycopg2_execution_options`
c C s< | j j j d d | _ | j t t | j d S( Nt max_row_buffer( RY R R R t _max_row_buffert$ _BufferedRowResultProxy__buffer_rowst superR R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR F s
i i i
i i2 id i i i c C s | j d k r d St | d d } t j | j j | | _ | j j | | | _ | j
d k r t | j
| j | _ n d S( Nt _bufsizei ( R R t getattrt collectionst dequeR t" _BufferedRowResultProxy__rowbuffert size_growthR R R t min( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyt
__buffer_rows\ s c K s' | j j t t | j | d S( N( R t clearR R R ( R t kw( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR e s
c C sL | j d k r | j d S| j s? | j | j s? d Sn | j j S( N( R R R R R t popleft( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR i s
c C sc | d k r | j Sg } x@ t d | D]/ } | j } | d k rN Pn | j | q, W| S( Ni ( R R R R R' ( R R R R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR r s
c C sQ | j d k r | j g S| j j | j j | j } t j | _ | S( N( R R R R t extendR R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR } s
N( R3 R4 RS R R R R R R R R ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR ( s
t FullyBufferedResultProxyc B sG e Z d Z d Z d Z d Z d Z d d Z d Z RS( s A result proxy 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.
c C s& t t | j | j | _ d S( N( R R R t _buffer_rowst$ _FullyBufferedResultProxy__rowbuffer( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c C s t j | j j S( N( R R R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s c K s' | j j t t | j | d S( N( R R R R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s' | j r | j j S| j d Sd S( N( R R R R ( R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C sc | d k r | j Sg } x@ t d | D]/ } | j } | d k rN Pn | j | q, W| S( Ni ( R R R R R' ( R R R R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
c C s2 | j s | j g S| j } t j | _ | S( N( R R R R R ( R R ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s
N(
R3 R4 RS R R R R R R R ( ( ( sK /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/result.pyR s t BufferedColumnRowc B s e Z d Z RS( c C s t | } d } x> | j D]3 } | d k rE | | | | | s@
BL
~^-