# we don't want to bother pinging on these.
return
- # turn off "close with result". This flag is only used with
- # "connectionless" execution, otherwise will be False in any case
- save_should_close_with_result = connection.should_close_with_result
- connection.should_close_with_result = False
-
try:
# run a SELECT 1. use a core select() so that
# the SELECT of a scalar value without a table is
connection.scalar(select(1))
else:
raise
- finally:
- # restore "close with result"
- connection.should_close_with_result = save_should_close_with_result
The above recipe has the advantage that we are making use of SQLAlchemy's
facilities for detecting those DBAPI exceptions that are known to indicate
static int KEY_INTEGER_ONLY = 0;
static int KEY_OBJECTS_ONLY = 1;
-static int KEY_OBJECTS_BUT_WARN = 2;
-//static int KEY_OBJECTS_NO_WARN = 3;
/****************
* BaseRow *
/* -1 can be either the actual value, or an error flag. */
return NULL;
- if (!asmapping && self->key_style == KEY_OBJECTS_BUT_WARN) {
- PyObject *tmp;
-
- tmp = PyObject_CallMethod(self->parent, "_warn_for_nonint", "O", key);
- if (tmp == NULL) {
- return NULL;
- }
- Py_DECREF(tmp);
- }
-
return BaseRow_getitem(self, index);
}
static PyObject *
BaseRow_subscript_mapping(BaseRow *self, PyObject *key)
{
- if (self->key_style == KEY_OBJECTS_BUT_WARN || self->key_style == KEY_INTEGER_ONLY) {
+ if (self->key_style == KEY_INTEGER_ONLY) {
return BaseRow_subscript_impl(self, key, 0);
}
else {
from .cursor import BufferedRowResultProxy
from .cursor import CursorResult
from .cursor import FullyBufferedResultProxy
-from .cursor import LegacyCursorResult
from .cursor import ResultProxy
from .interfaces import AdaptedConnection
from .interfaces import Compiled
from .result import result_tuple
from .result import ScalarResult
from .row import BaseRow
-from .row import LegacyRow
from .row import Row
from .row import RowMapping
from .url import make_url
import sys
from .interfaces import Connectable
+from .interfaces import ConnectionEventsTarget
from .interfaces import ExceptionContext
from .util import _distill_params
from .util import _distill_params_20
# used by sqlalchemy.engine.util.TransactionalContext
_trans_context_manager = None
+ # legacy as of 2.0, should be eventually deprecated and
+ # removed. was used in the "pre_ping" recipe that's been in the docs
+ # a long time
+ should_close_with_result = False
+
def __init__(
self,
engine,
connection=None,
- close_with_result=False,
_branch_from=None,
_execution_options=None,
_dispatch=None,
self._dbapi_connection = connection
self._execution_options = _execution_options
self._echo = _branch_from._echo
- self.should_close_with_result = False
self.dispatch = _dispatch
self._has_events = _branch_from._has_events
else:
self._transaction = self._nested_transaction = None
self.__savepoint_seq = 0
self.__in_begin = False
- self.should_close_with_result = close_with_result
self.__can_reconnect = _allow_revalidate
self._echo = self.engine._should_log_info()
def _branch(self):
"""Return a new Connection which references this Connection's
- engine and connection; but does not have close_with_result enabled,
- and also whose close() method does nothing.
+ engine and connection; whose close() method does nothing.
.. deprecated:: 1.4 the "branching" concept will be removed in
SQLAlchemy 2.0 as well as the "Connection.connect()" method which
return self.connection.info
@util.deprecated_20(":meth:`.Connection.connect`")
- def connect(self, close_with_result=False):
+ def connect(
+ self,
+ ):
"""Returns a branched version of this :class:`_engine.Connection`.
The :meth:`_engine.Connection.close` method on the returned
self._handle_dbapi_exception(e, None, None, None, None)
ret = ctx._exec_default(None, default, None)
- if self.should_close_with_result:
- self.close()
if self._has_events or self.engine._has_events:
self.dispatch.after_execute(
"""Create an :class:`.ExecutionContext` and execute, returning
a :class:`_engine.CursorResult`."""
- branched = self
if self.__branch_from:
# if this is a "branched" connection, do everything in terms
# of the "root" connection, *except* for .close(), which is
self._handle_dbapi_exception(
e, util.text_type(statement), parameters, None, None
)
+ return # not reached
if (
self._transaction
result = context._setup_result_proxy()
if not self._is_future:
- should_close_with_result = branched.should_close_with_result
-
- if not result._soft_closed and should_close_with_result:
- result._autoclose_connection = True
if (
# usually we're in a transaction so avoid relatively
):
self._commit_impl(autocommit=True)
- # for "connectionless" execution, we have to close this
- # Connection after the statement is complete.
- # legacy stuff.
- if should_close_with_result and context._soft_closed:
- assert not self._is_future
-
- # CursorResult already exhausted rows / has no rows.
- # close us now
- branched.close()
-
except BaseException as e:
self._handle_dbapi_exception(
e, statement, parameters, cursor, context
if invalidate_pool_on_disconnect:
self.engine.pool._invalidate(dbapi_conn_wrapper, e)
self.invalidate(e)
- if self.should_close_with_result:
- assert not self._is_future
- self.close()
@classmethod
def _handle_dbapi_exception_noconnection(cls, e, dialect, engine):
self.connection._commit_twophase_impl(self.xid, self._is_prepared)
-class Engine(Connectable, log.Identified):
+class Engine(ConnectionEventsTarget, log.Identified):
"""
Connects a :class:`~sqlalchemy.pool.Pool` and
:class:`~sqlalchemy.engine.interfaces.Dialect` together to provide a
yield connection
class _trans_ctx(object):
- def __init__(self, conn, transaction, close_with_result):
+ def __init__(self, conn, transaction):
self.conn = conn
self.transaction = transaction
- self.close_with_result = close_with_result
def __enter__(self):
self.transaction.__enter__()
try:
self.transaction.__exit__(type_, value, traceback)
finally:
- if not self.close_with_result:
- self.conn.close()
+ self.conn.close()
- def begin(self, close_with_result=False):
+ def begin(self):
"""Return a context manager delivering a :class:`_engine.Connection`
with a :class:`.Transaction` established.
is committed. If an error is raised, the :class:`.Transaction`
is rolled back.
- Legacy use only: the ``close_with_result`` flag is normally ``False``,
- and indicates that the :class:`_engine.Connection` will be closed when
- the operation is complete. When set to ``True``, it indicates the
- :class:`_engine.Connection` is in "single use" mode, where the
- :class:`_engine.CursorResult` returned by the first call to
- :meth:`_engine.Connection.execute` will close the
- :class:`_engine.Connection` when that :class:`_engine.CursorResult` has
- exhausted all result rows.
-
.. seealso::
:meth:`_engine.Engine.connect` - procure a
for a particular :class:`_engine.Connection`.
"""
- if self._connection_cls._is_future:
- conn = self.connect()
- else:
- conn = self.connect(close_with_result=close_with_result)
+ conn = self.connect()
try:
trans = conn.begin()
except:
with util.safe_reraise():
conn.close()
- return Engine._trans_ctx(conn, trans, close_with_result)
+ return Engine._trans_ctx(conn, trans)
@util.deprecated(
"1.4",
with self.begin() as conn:
conn._run_ddl_visitor(visitorcallable, element, **kwargs)
- @util.deprecated_20(
- ":meth:`_engine.Engine.execute`",
- alternative="All statement execution in SQLAlchemy 2.0 is performed "
- "by the :meth:`_engine.Connection.execute` method of "
- ":class:`_engine.Connection`, "
- "or in the ORM by the :meth:`.Session.execute` method of "
- ":class:`.Session`.",
- )
- def execute(self, statement, *multiparams, **params):
- """Executes the given construct and returns a
- :class:`_engine.CursorResult`.
-
- The arguments are the same as those used by
- :meth:`_engine.Connection.execute`.
-
- Here, a :class:`_engine.Connection` is acquired using the
- :meth:`_engine.Engine.connect` method, and the statement executed
- with that connection. The returned :class:`_engine.CursorResult`
- is flagged
- such that when the :class:`_engine.CursorResult` is exhausted and its
- underlying cursor is closed, the :class:`_engine.Connection`
- created here
- will also be closed, which allows its associated DBAPI connection
- resource to be returned to the connection pool.
-
- """
- connection = self.connect(close_with_result=True)
- return connection.execute(statement, *multiparams, **params)
-
- @util.deprecated_20(
- ":meth:`_engine.Engine.scalar`",
- alternative="All statement execution in SQLAlchemy 2.0 is performed "
- "by the :meth:`_engine.Connection.execute` method of "
- ":class:`_engine.Connection`, "
- "or in the ORM by the :meth:`.Session.execute` method of "
- ":class:`.Session`; the :meth:`_future.Result.scalar` "
- "method can then be "
- "used to return a scalar result.",
- )
- def scalar(self, statement, *multiparams, **params):
- """Executes and returns the first column of the first row.
-
- The underlying result/cursor is closed after execution.
- """
- return self.execute(statement, *multiparams, **params).scalar()
-
- def _execute_clauseelement(
- self,
- elem,
- multiparams=None,
- params=None,
- execution_options=_EMPTY_EXECUTION_OPTS,
- ):
- connection = self.connect(close_with_result=True)
- return connection._execute_clauseelement(
- elem, multiparams, params, execution_options
- )
-
- def _execute_compiled(
- self,
- compiled,
- multiparams,
- params,
- execution_options=_EMPTY_EXECUTION_OPTS,
- ):
- connection = self.connect(close_with_result=True)
- return connection._execute_compiled(
- compiled, multiparams, params, execution_options
- )
-
- def connect(self, close_with_result=False):
+ def connect(self):
"""Return a new :class:`_engine.Connection` object.
The :class:`_engine.Connection` object is a facade that uses a DBAPI
"""
- return self._connection_cls(self, close_with_result=close_with_result)
+ return self._connection_cls(self)
@util.deprecated(
"1.4",
from .result import ResultMetaData
from .result import SimpleResultMetaData
from .result import tuplegetter
-from .row import LegacyRow
+from .row import Row
from .. import exc
from .. import util
-from ..sql import expression
+from ..sql import elements
from ..sql import sqltypes
from ..sql import util as sql_util
from ..sql.base import _generative
"_keymap_by_result_column_idx",
"_tuplefilter",
"_translated_indexes",
- "_safe_for_cache"
+ "_safe_for_cache",
+ "_unpickled"
# don't need _unique_filters support here for now. Can be added
# if a need arises.
)
new_metadata = self.__class__.__new__(self.__class__)
new_metadata.case_sensitive = self.case_sensitive
+ new_metadata._unpickled = self._unpickled
new_metadata._processors = self._processors
new_metadata._keys = new_keys
new_metadata._tuplefilter = tup
md._keymap[new] = rec
md.case_sensitive = self.case_sensitive
+ md._unpickled = self._unpickled
md._processors = self._processors
assert not self._tuplefilter
md._tuplefilter = None
self._tuplefilter = None
self._translated_indexes = None
self.case_sensitive = dialect.case_sensitive
- self._safe_for_cache = False
+ self._safe_for_cache = self._unpickled = False
if context.result_column_struct:
(
)
def _key_fallback(self, key, err, raiseerr=True):
+
+ # we apparently have not marked .case_sensitive as
+ # RemovedIn20. I still think we should remove it as I can't
+ # imagine anyone is using it, however lets make that a separate
+ # commit.
+ if not self.case_sensitive and isinstance(key, util.string_types):
+ map_ = self._keymap
+ result = map_.get(key.lower())
+ if result is not None:
+ return result
+
if raiseerr:
- util.raise_(
- exc.NoSuchColumnError(
- "Could not locate column in row for column '%s'"
- % util.string_or_unprintable(key)
- ),
- replace_context=err,
- )
+ if self._unpickled and isinstance(key, elements.ColumnElement):
+ util.raise_(
+ exc.NoSuchColumnError(
+ "Row was unpickled; lookup by ColumnElement "
+ "is unsupported"
+ ),
+ replace_context=err,
+ )
+ else:
+ util.raise_(
+ exc.NoSuchColumnError(
+ "Could not locate column in row for column '%s'"
+ % util.string_or_unprintable(key)
+ ),
+ replace_context=err,
+ )
else:
return None
}
self._keys = state["_keys"]
self.case_sensitive = state["case_sensitive"]
-
+ self._unpickled = True
if state["_translated_indexes"]:
self._translated_indexes = state["_translated_indexes"]
self._tuplefilter = tuplegetter(*self._translated_indexes)
self._translated_indexes = self._tuplefilter = None
-class LegacyCursorResultMetaData(CursorResultMetaData):
- __slots__ = ()
-
- def _contains(self, value, row):
- key = value
- if key in self._keymap:
- util.warn_deprecated_20(
- "Using 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'",
- )
- return True
- else:
- return self._key_fallback(key, None, False) is not None
-
- def _key_fallback(self, key, err, raiseerr=True):
- map_ = self._keymap
- result = None
-
- if isinstance(key, util.string_types):
- result = map_.get(key if self.case_sensitive else key.lower())
- elif isinstance(key, expression.ColumnElement):
- if (
- key._tq_label
- and (
- key._tq_label
- if self.case_sensitive
- else key._tq_label.lower()
- )
- in map_
- ):
- result = map_[
- key._tq_label
- if self.case_sensitive
- else key._tq_label.lower()
- ]
- elif (
- hasattr(key, "name")
- and (key.name if self.case_sensitive else key.name.lower())
- in map_
- ):
- # match is only on name.
- result = map_[
- key.name if self.case_sensitive else key.name.lower()
- ]
-
- # search extra hard to make sure this
- # isn't a column/label name overlap.
- # this check isn't currently available if the row
- # was unpickled.
- if result is not None and result[MD_OBJECTS] not in (
- None,
- _UNPICKLED,
- ):
- for obj in result[MD_OBJECTS]:
- if key._compare_name_for_result(obj):
- break
- else:
- result = None
- if result is not None:
- if result[MD_OBJECTS] is _UNPICKLED:
- util.warn_deprecated(
- "Retrieving 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.",
- version="1.4",
- )
- else:
- util.warn_deprecated(
- "Retrieving 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.",
- version="1.4",
- )
- if result is None:
- if raiseerr:
- util.raise_(
- exc.NoSuchColumnError(
- "Could not locate column in row for column '%s'"
- % util.string_or_unprintable(key)
- ),
- replace_context=err,
- )
- else:
- return None
- else:
- map_[key] = result
- return result
-
- def _warn_for_nonint(self, key):
- util.warn_deprecated_20(
- "Using non-integer/slice indices on Row is deprecated and will "
- "be removed in version 2.0; please use row._mapping[<key>], or "
- "the mappings() accessor on the Result object.",
- stacklevel=4,
- )
-
- def _has_key(self, key):
- if key in self._keymap:
- return True
- else:
- return self._key_fallback(key, None, False) is not None
-
-
class ResultFetchStrategy(object):
"""Define a fetching strategy for a result object.
self._we_dont_return_rows()
-class _LegacyNoResultMetaData(_NoResultMetaData):
- @property
- def keys(self):
- util.warn_deprecated_20(
- "Calling the .keys() method on a result set that does not return "
- "rows is deprecated and will raise ResourceClosedError in "
- "SQLAlchemy 2.0.",
- )
- return []
-
-
_NO_RESULT_METADATA = _NoResultMetaData()
-_LEGACY_NO_RESULT_METADATA = _LegacyNoResultMetaData()
class BaseCursorResult(object):
class CursorResult(BaseCursorResult, Result):
"""A 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
+ .. versionchanged:: 1.4 The :class:`.CursorResult``
+ class replaces the previous :class:`.ResultProxy` interface.
+ This classes are based on the :class:`.Result` calling API
which provides an updated usage model and calling facade for
SQLAlchemy Core and SQLAlchemy ORM.
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
self.cursor_strategy.yield_per(self, self.cursor, num)
-class LegacyCursorResult(CursorResult):
- """Legacy 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
-
- """
-
- _autoclose_connection = False
- _process_row = LegacyRow
- _cursor_metadata = LegacyCursorResultMetaData
- _cursor_strategy_cls = CursorFetchStrategy
-
- _no_result_metadata = _LEGACY_NO_RESULT_METADATA
-
- def close(self):
- """Close 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`
- """
- self._soft_close(hard=True)
-
- def _soft_close(self, hard=False):
- soft_closed = self._soft_closed
- super(LegacyCursorResult, self)._soft_close(hard=hard)
- if (
- not soft_closed
- and self._soft_closed
- and self._autoclose_connection
- ):
- self.connection.close()
-
-
-ResultProxy = LegacyCursorResult
+ResultProxy = CursorResult
class BufferedRowResultProxy(ResultProxy):
_cursor_strategy_cls = FullyBufferedCursorFetchStrategy
-class BufferedColumnRow(LegacyRow):
+class BufferedColumnRow(Row):
"""Row is now BufferedColumn in all cases"""
_is_implicit_returning = False
_is_explicit_returning = False
- _is_future_result = False
_is_server_side = False
_soft_closed = False
self.execution_options = execution_options
- self._is_future_result = (
- connection._is_future
- or self.execution_options.get("future_result", False)
- )
-
self.unicode_statement = util.text_type(compiled)
if compiled.schema_translate_map:
schema_translate_map = self.execution_options.get(
self.execution_options = execution_options
- self._is_future_result = (
- connection._is_future
- or self.execution_options.get("future_result", False)
- )
-
self.result_column_struct = (
compiled._result_columns,
compiled._ordered_columns,
self.execution_options = execution_options
- self._is_future_result = (
- connection._is_future
- or self.execution_options.get("future_result", False)
- )
-
if not parameters:
if self.dialect.positional:
self.parameters = [dialect.execute_sequence_format()]
self.execution_options = execution_options
- self._is_future_result = (
- connection._is_future
- or self.execution_options.get("future_result", False)
- )
-
self.cursor = self.create_cursor()
return self
if cursor_description is None:
strategy = _cursor._NO_CURSOR_DQL
- if self._is_future_result:
- if self.root_connection.should_close_with_result:
- raise exc.InvalidRequestError(
- "can't use future_result=True with close_with_result"
- )
- result = _cursor.CursorResult(
- self, strategy, cursor_description
- )
- else:
- result = _cursor.LegacyCursorResult(
- self, strategy, cursor_description
- )
+ result = _cursor.CursorResult(self, strategy, cursor_description)
if (
self.compiled
if cursor_description is None:
strategy = _cursor._NO_CURSOR_DML
- if self._is_future_result:
- result = _cursor.CursorResult(self, strategy, cursor_description)
- else:
- result = _cursor.LegacyCursorResult(
- self, strategy, cursor_description
- )
+ result = _cursor.CursorResult(self, strategy, cursor_description)
if self.isinsert:
if self._is_implicit_returning:
from .base import Engine
-from .interfaces import Connectable
+from .interfaces import ConnectionEventsTarget
from .interfaces import Dialect
from .. import event
from .. import exc
class ConnectionEvents(event.Events):
- """Available events for :class:`.Connectable`, which includes
+ """Available events for
:class:`_engine.Connection` and :class:`_engine.Engine`.
The methods here define the name of an event as well as the names of
members that are passed to listener functions.
- An event listener can be associated with any :class:`.Connectable`
+ An event listener can be associated with any
+ :class:`_engine.Connection` or :class:`_engine.Engine`
class or instance, such as an :class:`_engine.Engine`, e.g.::
from sqlalchemy import event, create_engine
"""
_target_class_doc = "SomeEngine"
- _dispatch_target = Connectable
+ _dispatch_target = ConnectionEventsTarget
@classmethod
def _listen(cls, event_key, retval=False):
"""Define core interfaces used by the engine system."""
-from .. import util
from ..sql.compiler import Compiled # noqa
from ..sql.compiler import TypeCompiler # noqa
root_connection.
root_connection
- Connection object which is the source of this ExecutionContext. This
- Connection may have close_with_result=True set, in which case it can
- only be used once.
+ Connection object which is the source of this ExecutionContext.
dialect
dialect which created this ExecutionContext.
raise NotImplementedError()
-@util.deprecated_20_cls(
- ":class:`.Connectable`",
- alternative=(
- "The :class:`_engine.Engine` will be the only Core "
- "object that features a .connect() method, and the "
- ":class:`_engine.Connection` will be the only object that features "
- "an .execute() method."
- ),
- constructor=None,
-)
-class Connectable(object):
- """Interface for an object which supports execution of SQL constructs.
+class ConnectionEventsTarget:
+ """An object which can accept events from :class:`.ConnectionEvents`.
- The two implementations of :class:`.Connectable` are
- :class:`_engine.Connection` and :class:`_engine.Engine`.
+ Includes :class:`_engine.Connection` and :class:`_engine.Engine`.
- Connectable must also implement the 'dialect' member which references a
- :class:`.Dialect` instance.
+ .. versionadded:: 2.0
"""
- def connect(self, **kwargs):
- """Return a :class:`_engine.Connection` object.
- Depending on context, this may be ``self`` if this object
- is already an instance of :class:`_engine.Connection`, or a newly
- procured :class:`_engine.Connection` if this object is an instance
- of :class:`_engine.Engine`.
+class Connectable(ConnectionEventsTarget):
+ """Interface for an object which supports execution of SQL constructs.
+
+ This is the base for :class:`_engine.Connection` and similar objects.
- """
+ .. versionchanged:: 2.0 :class:`_engine.Connectable` is no longer the
+ base class for :class:`_engine.Engine`, replaced with
+ :class:`_engine.ConnectionEventsTarget`.
+
+ """
engine = None
"""The :class:`_engine.Engine` instance referred to by this
:class:`.Connectable`.
- May be ``self`` if this is already an :class:`_engine.Engine`.
+ """
+
+ dialect = None
+ """The :class:`_engine.Dialect` instance referred to by this
+ :class:`.Connectable`.
"""
def execute(self, object_, *multiparams, **params):
"""Executes the given construct and returns a
- :class:`_engine.CursorResult`.
+ :class:`_result.Result`.
+
"""
raise NotImplementedError()
"""Executes and returns the first column of the first row.
The underlying cursor is closed after execution.
- """
- raise NotImplementedError()
- def _run_visitor(self, visitorcallable, element, **kwargs):
- raise NotImplementedError()
-
- def _execute_clauseelement(self, elem, multiparams=None, params=None):
+ """
raise NotImplementedError()
from . import base
from . import url as _url
from .. import util
-from ..sql import ddl
class MockConnection(base.Connectable):
dialect = property(attrgetter("_dialect"))
name = property(lambda s: s._dialect.name)
- def schema_for_object(self, obj):
- return obj.schema
-
def connect(self, **kwargs):
return self
+ def schema_for_object(self, obj):
+ return obj.schema
+
def execution_options(self, **kw):
return self
- def compiler(self, statement, parameters, **kwargs):
- return self._dialect.compiler(
- statement, parameters, engine=self, **kwargs
- )
-
- def create(self, entity, **kwargs):
- kwargs["checkfirst"] = False
-
- ddl.SchemaGenerator(self.dialect, self, **kwargs).traverse_single(
- entity
- )
-
- def drop(self, entity, **kwargs):
- kwargs["checkfirst"] = False
-
- ddl.SchemaDropper(self.dialect, self, **kwargs).traverse_single(entity)
-
def _run_ddl_visitor(
self, visitorcallable, element, connection=None, **kwargs
):
if _baserow_usecext:
from sqlalchemy.cresultproxy import tuplegetter
-
- _row_as_tuple = tuplegetter
else:
def tuplegetter(*indexes):
else:
return lambda row: (it(row),)
- def _row_as_tuple(*indexes):
- # circumvent LegacyRow.__getitem__ pointing to
- # _get_by_key_impl_mapping for now. otherwise we could
- # use itemgetter
- getters = [
- operator.methodcaller("_get_by_int_impl", index)
- for index in indexes
- ]
- return lambda rec: tuple([getter(rec) for getter in getters])
-
class ResultMetaData(object):
"""Base for metadata about result rows."""
assert raiseerr
util.raise_(KeyError(key), replace_context=err)
- def _warn_for_nonint(self, key):
- util.warn_deprecated_20(
- "Retrieving row members using strings or other non-integers is "
- "deprecated; use row._mapping for a dictionary interface "
- "to the row"
- )
-
def _raise_for_nonint(self, key):
raise TypeError(
"TypeError: tuple indices must be integers or slices, not %s"
def _row_as_tuple_getter(self, keys):
indexes = self._indexes_for_keys(keys)
- return _row_as_tuple(*indexes)
+ return tuplegetter(*indexes)
class RMKeyView(collections_abc.KeysView):
KEY_INTEGER_ONLY = 0
-"""__getitem__ only allows integer values, raises TypeError otherwise"""
+"""__getitem__ only allows integer values and slices, raises TypeError
+ otherwise"""
KEY_OBJECTS_ONLY = 1
"""__getitem__ only allows string/object values, raises TypeError otherwise"""
-KEY_OBJECTS_BUT_WARN = 2
-"""__getitem__ allows integer or string/object values, but emits a 2.0
-deprecation warning if string/object is passed"""
-
-KEY_OBJECTS_NO_WARN = 3
-"""__getitem__ allows integer or string/object values with no warnings
-or errors."""
-
try:
from sqlalchemy.cresultproxy import BaseRow
if int in key.__class__.__mro__:
return self._data[key]
- if self._key_style == KEY_INTEGER_ONLY:
- self._parent._raise_for_nonint(key)
-
- # the following is all LegacyRow support. none of this
- # should be called if not LegacyRow
- # assert isinstance(self, LegacyRow)
-
- try:
- rec = self._keymap[key]
- except KeyError as ke:
- rec = self._parent._key_fallback(key, ke)
- except TypeError:
- if isinstance(key, slice):
- return tuple(self._data[key])
- else:
- raise
-
- mdindex = rec[MD_INDEX]
- if mdindex is None:
- self._parent._raise_for_ambiguous_column_name(rec)
+ assert self._key_style == KEY_INTEGER_ONLY
- elif self._key_style == KEY_OBJECTS_BUT_WARN and mdindex != key:
- self._parent._warn_for_nonint(key)
+ if isinstance(key, slice):
+ return tuple(self._data[key])
- return self._data[mdindex]
+ self._parent._raise_for_nonint(key)
# The original 1.4 plan was that Row would not allow row["str"]
# access, however as the C extensions were inadvertently allowing
:ref:`coretutorial_selecting` - includes examples of selecting
rows from SELECT statements.
- :class:`.LegacyRow` - Compatibility interface introduced in SQLAlchemy
- 1.4.
-
.. versionchanged:: 1.4
- Renamed ``RowProxy`` to :class:`.Row`. :class:`.Row` is no longer a
+ Renamed ``RowProxy`` to :class:`.Row`. :class:`.Row` is no longer a
"proxy" object in that it contains the final form of data within it,
- and now acts mostly like a named tuple. Mapping-like functionality is
- moved to the :attr:`.Row._mapping` attribute, but will remain available
- in SQLAlchemy 1.x series via the :class:`.LegacyRow` class that is used
- by :class:`_engine.LegacyCursorResult`.
- See :ref:`change_4710_core` for background
- on this change.
+ and now acts mostly like a named tuple. Mapping-like functionality is
+ moved to the :attr:`.Row._mapping` attribute. See
+ :ref:`change_4710_core` for background on this change.
"""
__slots__ = ()
- # in 2.0, this should be KEY_INTEGER_ONLY
- _default_key_style = KEY_OBJECTS_BUT_WARN
+ _default_key_style = KEY_INTEGER_ONLY
@property
def _mapping(self):
This object provides a consistent Python mapping (i.e. dictionary)
interface for the data contained within the row. The :class:`.Row`
- by itself behaves like a named tuple, however in the 1.4 series of
- SQLAlchemy, the :class:`.LegacyRow` class is still used by Core which
- continues to have mapping-like behaviors against the row object
- itself.
+ by itself behaves like a named tuple.
.. seealso::
def __repr__(self):
return repr(sql_util._repr_row(self))
- @util.deprecated_20(
- ":meth:`.Row.keys`",
- alternative="Use the namedtuple standard accessor "
- ":attr:`.Row._fields`, or for full mapping behavior use "
- "row._mapping.keys() ",
- )
- def keys(self):
- """Return the list of keys as strings represented by this
- :class:`.Row`.
-
- The keys can represent the labels of the columns returned by a core
- statement or the names of the orm classes returned by an orm
- execution.
-
- This method is analogous to the Python dictionary ``.keys()`` method,
- except that it returns a list, not an iterator.
-
- .. seealso::
-
- :attr:`.Row._fields`
-
- :attr:`.Row._mapping`
-
- """
- return self._parent.keys
-
@property
def _fields(self):
"""Return a tuple of string keys as represented by this
raise NotImplementedError()
-class LegacyRow(Row):
- """A subclass of :class:`.Row` that delivers 1.x SQLAlchemy behaviors
- for Core.
-
- The :class:`.LegacyRow` class is where most of the Python mapping
- (i.e. dictionary-like)
- behaviors are implemented for the row object. The mapping behavior
- of :class:`.Row` going forward is accessible via the :class:`.Row._mapping`
- attribute.
-
- .. versionadded:: 1.4 - added :class:`.LegacyRow` which encapsulates most
- of the deprecated behaviors of :class:`.Row`.
-
- """
-
- __slots__ = ()
-
- if util.SQLALCHEMY_WARN_20:
- _default_key_style = KEY_OBJECTS_BUT_WARN
- else:
- _default_key_style = KEY_OBJECTS_NO_WARN
-
- def __contains__(self, key):
- return self._parent._contains(key, self)
-
- # prior to #6218, LegacyRow would redirect the behavior of __getitem__
- # for the non C version of BaseRow. This is now set up by Python BaseRow
- # in all cases
- # if not _baserow_usecext:
- # __getitem__ = BaseRow._get_by_key_impl
-
- @util.deprecated(
- "1.4",
- "The :meth:`.LegacyRow.has_key` method is deprecated and will be "
- "removed in a future release. To test for key membership, use "
- "the :attr:`Row._mapping` attribute, i.e. 'key in row._mapping`.",
- )
- def has_key(self, key):
- """Return True if this :class:`.LegacyRow` contains the given key.
-
- Through the SQLAlchemy 1.x series, the ``__contains__()`` method of
- :class:`.Row` (or :class:`.LegacyRow` as of SQLAlchemy 1.4) also links
- to :meth:`.Row.has_key`, in that an expression such as ::
-
- "some_col" in row
-
- Will return True if the row contains a column named ``"some_col"``,
- in the way that a Python mapping works.
-
- However, it is planned that the 2.0 series of SQLAlchemy will reverse
- this behavior so that ``__contains__()`` will refer to a value being
- present in the row, in the way that a Python tuple works.
-
- .. seealso::
-
- :ref:`change_4710_core`
-
- """
-
- return self._parent._has_key(key)
-
- @util.deprecated(
- "1.4",
- "The :meth:`.LegacyRow.items` method is deprecated and will be "
- "removed in a future release. Use the :attr:`Row._mapping` "
- "attribute, i.e., 'row._mapping.items()'.",
- )
- def items(self):
- """Return a list of tuples, each tuple containing a key/value pair.
-
- This method is analogous to the Python dictionary ``.items()`` method,
- except that it returns a list, not an iterator.
-
- """
-
- return [(key, self[key]) for key in self.keys()]
-
- @util.deprecated(
- "1.4",
- "The :meth:`.LegacyRow.iterkeys` method is deprecated and will be "
- "removed in a future release. Use the :attr:`Row._mapping` "
- "attribute, i.e., 'row._mapping.keys()'.",
- )
- def iterkeys(self):
- """Return a an iterator against the :meth:`.Row.keys` method.
-
- This method is analogous to the Python-2-only dictionary
- ``.iterkeys()`` method.
-
- """
- return iter(self._parent.keys)
-
- @util.deprecated(
- "1.4",
- "The :meth:`.LegacyRow.itervalues` method is deprecated and will be "
- "removed in a future release. Use the :attr:`Row._mapping` "
- "attribute, i.e., 'row._mapping.values()'.",
- )
- def itervalues(self):
- """Return a an iterator against the :meth:`.Row.values` method.
-
- This method is analogous to the Python-2-only dictionary
- ``.itervalues()`` method.
-
- """
- return iter(self)
-
- @util.deprecated(
- "1.4",
- "The :meth:`.LegacyRow.values` method is deprecated and will be "
- "removed in a future release. Use the :attr:`Row._mapping` "
- "attribute, i.e., 'row._mapping.values()'.",
- )
- def values(self):
- """Return the values represented by this :class:`.Row` as a list.
-
- This method is analogous to the Python dictionary ``.values()`` method,
- except that it returns a list, not an iterator.
-
- """
-
- return self._values_impl()
-
-
BaseRowProxy = BaseRow
RowProxy = Row
"""
return self._execution_options
- @util.deprecated_20(
- ":meth:`.Executable.execute`",
- alternative="All statement execution in SQLAlchemy 2.0 is performed "
- "by the :meth:`_engine.Connection.execute` method of "
- ":class:`_engine.Connection`, "
- "or in the ORM by the :meth:`.Session.execute` method of "
- ":class:`.Session`.",
- )
- def execute(self, *multiparams, **params):
- """Compile and execute this :class:`.Executable`."""
- e = self.bind
- if e is None:
- label = (
- getattr(self, "description", None) or self.__class__.__name__
- )
- msg = (
- "This %s is not directly bound to a Connection or Engine. "
- "Use the .execute() method of a Connection or Engine "
- "to execute this construct." % label
- )
- raise exc.UnboundExecutionError(msg)
- return e._execute_clauseelement(
- self, multiparams, params, util.immutabledict()
- )
-
- @util.deprecated_20(
- ":meth:`.Executable.scalar`",
- alternative="Scalar execution in SQLAlchemy 2.0 is performed "
- "by the :meth:`_engine.Connection.scalar` method of "
- ":class:`_engine.Connection`, "
- "or in the ORM by the :meth:`.Session.scalar` method of "
- ":class:`.Session`.",
- )
- def scalar(self, *multiparams, **params):
- """Compile and execute this :class:`.Executable`, returning the
- result's scalar representation.
-
- """
- return self.execute(*multiparams, **params).scalar()
-
@property
@util.deprecated_20(
":attr:`.Executable.bind`",
# passed in. for ORM use this will convert from an ORM-state
# SELECT to a regular "Core" SELECT. other composed operations
# such as computation of joins will be performed.
+ kwargs["within_columns_clause"] = False
+
compile_state = select_stmt._compile_state_factory(
select_stmt, self, **kwargs
)
else:
self.column.default = self
- @util.deprecated_20(
- ":meth:`.DefaultGenerator.execute`",
- alternative="All statement execution in SQLAlchemy 2.0 is performed "
- "by the :meth:`_engine.Connection.execute` method of "
- ":class:`_engine.Connection`, "
- "or in the ORM by the :meth:`.Session.execute` method of "
- ":class:`.Session`.",
- )
- def execute(self, bind=None):
- if bind is None:
- bind = _bind_or_error(self)
- return bind._execute_default(self, (), util.EMPTY_DICT)
-
def _execute_on_connection(
self, connection, multiparams, params, execution_options
):
with mock.patch("warnings.warn", our_warn), mock.patch(
"sqlalchemy.util.SQLALCHEMY_WARN_20", True
- ), mock.patch(
- "sqlalchemy.util.deprecations.SQLALCHEMY_WARN_20", True
- ), mock.patch(
- "sqlalchemy.engine.row.LegacyRow._default_key_style", 2
- ):
+ ), mock.patch("sqlalchemy.util.deprecations.SQLALCHEMY_WARN_20", True):
try:
yield
finally:
from sqlalchemy.util import decorator
from sqlalchemy.util import deprecations
- from sqlalchemy.engine import row
from sqlalchemy.testing import mock
@decorator
def wrap(fn, *args, **kw):
- with mock.patch.object(
- deprecations, "SQLALCHEMY_WARN_20", False
- ), mock.patch.object(
- row.LegacyRow, "_default_key_style", row.KEY_OBJECTS_NO_WARN
- ):
+ with mock.patch.object(deprecations, "SQLALCHEMY_WARN_20", False):
for warm in range(warmup):
fn(*args, **kw)
eq_(connection.execute(select, params).fetchall(), result)
def _assert_result_str(self, select, result, params=()):
- conn = config.db.connect(close_with_result=True)
- eq_(conn.exec_driver_sql(select, params).fetchall(), result)
+ with config.db.connect() as conn:
+ eq_(conn.exec_driver_sql(select, params).fetchall(), result)
def test_simple_limit(self, connection):
table = self.tables.some_table
[tox]
-envlist = py{27,39}-sqla_{cext,nocext}-db_{sqlite,postgresql,mysql,oracle,mssql}
+envlist = py{310}-sqla_{cext,nocext}-db_{sqlite,postgresql,mysql,oracle,mssql}
[testenv]
deps=pytest
metadata.drop_all(self.engine)
assert_no_mappers()
- @testing.uses_deprecated()
- def test_key_fallback_result(self):
- m = MetaData()
- e = self.engine
- t = Table("t", m, Column("x", Integer), Column("y", Integer))
- m.create_all(e)
- e.execute(t.insert(), {"x": 1, "y": 1})
-
- @profile_memory()
- def go():
- r = e.execute(t.alias().select())
- for row in r:
- row[t.c.x]
-
- try:
- go()
- finally:
- m.drop_all(e)
-
def test_many_discarded_relationships(self):
"""a use case that really isn't supported, nonetheless we can
guard against memleaks here so why not"""
from sqlalchemy import Table
from sqlalchemy import testing
from sqlalchemy import Unicode
-from sqlalchemy.engine.row import LegacyRow
from sqlalchemy.engine.row import Row
from sqlalchemy.testing import AssertsExecutionResults
from sqlalchemy.testing import eq_
with testing.db.connect() as conn:
[tuple(row) for row in conn.exec_driver_sql(stmt).fetchall()]
- @profiling.function_call_count()
- def test_fetch_by_key_legacy(self):
- t, t2 = self.tables("table1", "table2")
- with testing.db.connect().execution_options(
- compiled_cache=None
- ) as conn:
- for row in conn.execute(t.select()).fetchall():
- [row["field%d" % fnum] for fnum in range(NUM_FIELDS)]
-
@profiling.function_call_count()
def test_fetch_by_key_mappings(self):
t, t2 = self.tables("table1", "table2")
@profiling.function_call_count(variance=0.10)
def go():
- c1 in row
+ c1 in row._mapping
go()
metadata, processors, keymap, row_cls._default_key_style, row
)
- def _test_getitem_value_refcounts_legacy(self, seq_factory):
- col1, col2 = object(), object()
-
- def proc1(value):
- return value
-
- value1, value2 = "x", "y"
- row = self._rowproxy_fixture(
- [(col1, "a"), (col2, "b")],
- [proc1, None],
- seq_factory([value1, value2]),
- LegacyRow,
- )
-
- v1_refcount = sys.getrefcount(value1)
- v2_refcount = sys.getrefcount(value2)
- for i in range(10):
- row[col1]
- row["a"]
- row[col2]
- row["b"]
- row[0]
- row[1]
- row[0:2]
- eq_(sys.getrefcount(value1), v1_refcount)
- eq_(sys.getrefcount(value2), v2_refcount)
-
def _test_getitem_value_refcounts_new(self, seq_factory):
col1, col2 = object(), object()
eq_(sys.getrefcount(value2), v2_refcount)
def test_value_refcounts_pure_tuple(self):
- self._test_getitem_value_refcounts_legacy(tuple)
self._test_getitem_value_refcounts_new(tuple)
def test_value_refcounts_custom_seq(self):
def __iter__(self):
return iter(self.data)
- self._test_getitem_value_refcounts_legacy(CustomSeq)
self._test_getitem_value_refcounts_new(CustomSeq)
if isinstance(bind, engine.Connection):
bind.close()
- def test_bind_implicit_execution(self):
- metadata = MetaData()
- table = Table(
- "test_table",
- metadata,
- Column("foo", Integer),
- test_needs_acid=True,
- )
- conn = testing.db.connect()
- with conn.begin():
- metadata.create_all(bind=conn)
- try:
- trans = conn.begin()
- metadata.bind = conn
- t = table.insert()
- assert t.bind is conn
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
- ):
- table.insert().execute(foo=5)
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
- ):
- table.insert().execute(foo=6)
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
- ):
- table.insert().execute(foo=7)
- trans.rollback()
- metadata.bind = None
- assert (
- conn.exec_driver_sql(
- "select count(*) from test_table"
- ).scalar()
- == 0
- )
- finally:
- with conn.begin():
- metadata.drop_all(bind=conn)
-
- def test_bind_clauseelement(self):
- metadata = MetaData()
+ def test_bind_clauseelement(self, metadata):
table = Table("test_table", metadata, Column("foo", Integer))
metadata.create_all(bind=testing.db)
- try:
- for elem in [
- table.select,
- lambda **kwargs: sa.func.current_timestamp(**kwargs).select(),
- # func.current_timestamp().select,
- lambda **kwargs: text("select * from test_table", **kwargs),
- ]:
- for bind in (testing.db, testing.db.connect()):
- try:
- with testing.expect_deprecated_20(
- "The .*bind argument is deprecated"
- ):
- e = elem(bind=bind)
- assert e.bind is bind
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is "
- "considered legacy"
- ):
- e.execute().close()
- finally:
- if isinstance(bind, engine.Connection):
- bind.close()
-
- e = elem()
- assert e.bind is None
+ for elem in [
+ table.select,
+ lambda **kwargs: sa.func.current_timestamp(**kwargs).select(),
+ # func.current_timestamp().select,
+ lambda **kwargs: text("select * from test_table", **kwargs),
+ ]:
+ with testing.db.connect() as bind:
with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
+ "The .*bind argument is deprecated"
):
- assert_raises(exc.UnboundExecutionError, e.execute)
- finally:
- if isinstance(bind, engine.Connection):
- bind.close()
- metadata.drop_all(bind=testing.db)
+ e = elem(bind=bind)
+ assert e.bind is bind
def test_inspector_constructor_engine(self):
with testing.expect_deprecated(
assert not conn.closed
assert c2.closed
- @testing.provide_metadata
- def test_explicit_connectionless_execute(self):
- table = Table("t", self.metadata, Column("a", Integer))
- table.create(testing.db)
-
- stmt = table.insert().values(a=1)
- with testing.expect_deprecated_20(
- r"The Engine.execute\(\) method is considered legacy",
- ):
- testing.db.execute(stmt)
-
- stmt = select(table)
- with testing.expect_deprecated_20(
- r"The Engine.execute\(\) method is considered legacy",
- ):
- eq_(testing.db.execute(stmt).fetchall(), [(1,)])
-
- def test_implicit_execute(self, metadata):
- table = Table("t", metadata, Column("a", Integer))
- table.create(testing.db)
-
- metadata.bind = testing.db
- stmt = table.insert().values(a=1)
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy",
- ):
- stmt.execute()
-
- stmt = select(table)
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy",
- ):
- eq_(stmt.execute().fetchall(), [(1,)])
-
class CreateEngineTest(fixtures.TestBase):
def test_strategy_keyword_mock(self):
self._assert_no_data()
def test_execute_plain_string(self):
- with _string_deprecation_expect():
- testing.db.execute(select1(testing.db)).scalar()
+ with testing.db.connect() as conn:
+ with _string_deprecation_expect():
+ conn.execute(select1(testing.db)).scalar()
def test_execute_plain_string_events(self):
)
def test_scalar_plain_string(self):
- with _string_deprecation_expect():
- testing.db.scalar(select1(testing.db))
+ with testing.db.connect() as conn:
+ with _string_deprecation_expect():
+ conn.scalar(select1(testing.db))
# Tests for the warning when non dict params are used
# @testing.combinations(42, (42,))
r"The argument signature for the "
r"\"ConnectionEvents.before_execute\" event listener",
):
- engine.execute(select(1))
+ with engine.connect() as conn:
+ conn.execute(select(1))
eq_(canary, ["execute", "cursor_execute"])
def test_argument_format_execute(self):
r"The argument signature for the "
r"\"ConnectionEvents.after_execute\" event listener",
):
- result = e1.execute(select(1))
- result.close()
+ with e1.connect() as conn:
+ result = conn.execute(select(1))
+ result.close()
class DDLExecutionTest(fixtures.TestBase):
Column("user_name", String(40)),
)
- @testing.requires.sqlite
- def test_ddl_execute(self):
- engine = create_engine("sqlite:///")
- cx = engine.connect()
- table = self.users
- ddl = DDL("SELECT 1")
-
- eng_msg = r"The Engine.execute\(\) method is considered legacy"
- ddl_msg = r"The DDLElement.execute\(\) method is considered legacy"
- for spec in (
- (engine.execute, ddl, eng_msg),
- (engine.execute, ddl, table, eng_msg),
- (ddl.execute, engine, ddl_msg),
- (ddl.execute, engine, table, ddl_msg),
- (ddl.execute, cx, ddl_msg),
- (ddl.execute, cx, table, ddl_msg),
- ):
- fn = spec[0]
- arg = spec[1:-1]
- warning = spec[-1]
-
- with testing.expect_deprecated_20(warning):
- r = fn(*arg)
- eq_(list(r), [(1,)])
-
- for fn, kw in ((ddl.execute, {}), (ddl.execute, dict(target=table))):
- with testing.expect_deprecated_20(ddl_msg):
- assert_raises(exc.UnboundExecutionError, fn, **kw)
-
- for bind in engine, cx:
- ddl.bind = bind
- for fn, kw in (
- (ddl.execute, {}),
- (ddl.execute, dict(target=table)),
- ):
- with testing.expect_deprecated_20(ddl_msg):
- r = fn(**kw)
- eq_(list(r), [(1,)])
-
class AutocommitKeywordFixture(object):
def _test_keyword(self, keyword, expected=True):
from sqlalchemy.testing import engines
from sqlalchemy.testing import eq_
from sqlalchemy.testing import expect_raises
-from sqlalchemy.testing import expect_warnings
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import is_
from sqlalchemy.testing import is_false
select(1),
)
- def test_noreconnect_execute_plus_closewresult(self):
- conn = self.db.connect(close_with_result=True)
+ def test_noreconnect_execute(self):
+ conn = self.db.connect()
self.dbapi.shutdown("execute_no_disconnect")
select(1),
)
- assert conn.closed
+ assert not conn.closed
assert not conn.invalidated
- def test_noreconnect_rollback_plus_closewresult(self):
- conn = self.db.connect(close_with_result=True)
+ conn.close()
+
+ def test_noreconnect_rollback(self):
+ conn = self.db.connect()
self.dbapi.shutdown("rollback_no_disconnect")
# raises error
- with expect_warnings(
- "An exception has occurred during handling .*"
- "something broke on execute but we didn't lose the connection",
- py2konly=True,
- ):
- assert_raises_message(
- tsa.exc.DBAPIError,
- "something broke on rollback but we didn't "
- "lose the connection",
- conn.execute,
- select(1),
- )
+ assert_raises_message(
+ tsa.exc.DBAPIError,
+ "something broke on rollback but we didn't " "lose the connection",
+ conn.execute,
+ select(1),
+ )
- assert conn.closed
+ assert not conn.closed
assert not conn.invalidated
+ conn.close()
+
assert_raises_message(
tsa.exc.ResourceClosedError,
"This Connection is closed",
self.dbapi.shutdown("rollback")
- # raises error
- with expect_warnings(
- "An exception has occurred during handling .*"
- "something broke on execute but we didn't lose the connection",
- py2konly=True,
- ):
- assert_raises_message(
- tsa.exc.DBAPIError,
- "Lost the DB connection on rollback",
- conn.execute,
- select(1),
- )
-
- assert not conn.closed
- assert conn.invalidated
-
- def test_reconnect_on_reentrant_plus_closewresult(self):
- conn = self.db.connect(close_with_result=True)
-
- self.dbapi.shutdown("rollback")
-
- # raises error
- with expect_warnings(
- "An exception has occurred during handling .*"
- "something broke on execute but we didn't lose the connection",
- py2konly=True,
- ):
- assert_raises_message(
- tsa.exc.DBAPIError,
- "Lost the DB connection on rollback",
- conn.execute,
- select(1),
- )
-
- assert conn.closed
- assert not conn.invalidated
-
assert_raises_message(
- tsa.exc.ResourceClosedError,
- "This Connection is closed",
+ tsa.exc.DBAPIError,
+ "Lost the DB connection on rollback",
conn.execute,
select(1),
)
+ assert not conn.closed
+ assert conn.invalidated
+
def test_check_disconnect_no_cursor(self):
conn = self.db.connect()
result = conn.execute(select(1))
with self.engine.connect() as conn:
self.engine.test_shutdown()
- with expect_warnings(
- "An exception has occurred during handling .*", py2konly=True
- ):
- assert_raises(tsa.exc.DBAPIError, conn.execute, select(1))
+ assert_raises(tsa.exc.DBAPIError, conn.execute, select(1))
def test_rollback_on_invalid_plain(self):
with self.engine.connect() as conn:
self.assert_sql_count(testing.db, go, 1)
- def test_contains_eager_string_alias(self):
- addresses, users, User = (
- self.tables.addresses,
- self.tables.users,
- self.classes.User,
- )
-
- sess = fixture_session()
- q = sess.query(User)
-
- adalias = addresses.alias("adalias")
- selectquery = (
- users.outerjoin(adalias)
- .select()
- .order_by(users.c.id, adalias.c.id)
- )
-
- # note this has multiple problems because we aren't giving Query
- # the statement where it would be able to create an adapter
- def go():
- with testing.expect_deprecated(
- r"Using the Query.instances\(\) method without a context",
- r"Passing a string name for the 'alias' argument to "
- r"'contains_eager\(\)` is deprecated",
- "Retrieving row values using Column objects with only "
- "matching names",
- ):
- result = list(
- q.options(
- contains_eager("addresses", alias="adalias")
- ).instances(sess.connection().execute(selectquery))
- )
- assert self.static.user_address_result == result
-
- self.assert_sql_count(testing.db, go, 1)
-
def test_contains_eager_aliased_instances(self):
addresses, users, User = (
self.tables.addresses,
self.assert_sql_count(testing.db, go, 1)
- def test_contains_eager_multi_string_alias(self):
- orders, items, users, order_items, User = (
- self.tables.orders,
- self.tables.items,
- self.tables.users,
- self.tables.order_items,
- self.classes.User,
- )
-
- sess = fixture_session()
- q = sess.query(User)
-
- oalias = orders.alias("o1")
- ialias = items.alias("i1")
- query = (
- users.outerjoin(oalias)
- .outerjoin(order_items)
- .outerjoin(ialias)
- .select()
- .order_by(users.c.id, oalias.c.id, ialias.c.id)
- )
-
- # test using string alias with more than one level deep
- def go():
- with testing.expect_deprecated(
- r"Using the Query.instances\(\) method without a context",
- r"Passing a string name for the 'alias' argument to "
- r"'contains_eager\(\)` is deprecated",
- "Retrieving row values using Column objects with only "
- "matching names",
- ):
- result = list(
- q.options(
- contains_eager("orders", alias="o1"),
- contains_eager("orders.items", alias="i1"),
- ).instances(sess.connection().execute(query))
- )
- assert self.static.user_order_result == result
-
- self.assert_sql_count(testing.db, go, 1)
-
def test_contains_eager_multi_alias(self):
orders, items, users, order_items, User = (
self.tables.orders,
# TEST: test.aaa_profiling.test_compiler.CompileTest.test_insert
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 66
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 73
-test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 73
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 72
+test.aaa_profiling.test_compiler.CompileTest.test_insert x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 72
# TEST: test.aaa_profiling.test_compiler.CompileTest.test_select
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 181
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 196
-test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 196
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 195
+test.aaa_profiling.test_compiler.CompileTest.test_select x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 195
# TEST: test.aaa_profiling.test_compiler.CompileTest.test_select_labels
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 205
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 212
-test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 212
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 219
+test.aaa_profiling.test_compiler.CompileTest.test_select_labels x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 219
# TEST: test.aaa_profiling.test_compiler.CompileTest.test_update
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 69
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 69
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 69
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 69
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 79
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 82
-test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 82
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 81
+test.aaa_profiling.test_compiler.CompileTest.test_update x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 81
# TEST: test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 169
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 175
-test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 175
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 174
+test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 174
# TEST: test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_cached
-test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_cached x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 303
-test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_cached x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 303
+test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_cached x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 303
+test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_cached x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 303
# TEST: test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_not_cached
-test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_not_cached x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 5403
-test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_not_cached x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 5403
+test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_not_cached x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 5003
+test.aaa_profiling.test_misc.CacheKeyTest.test_statement_key_is_not_cached x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 5003
# TEST: test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members
-test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 1328
-test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1328
-test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 929
-test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 929
+test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 929
+test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 929
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 49105
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 60305
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 52805
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 64905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 52705
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 64305
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 47805
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 51505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 63605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 51405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 63005
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 51705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 60405
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 54805
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 64405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 55905
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 65005
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 50805
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 59505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 53905
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 63505
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 55005
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 64105
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 45205
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 48905
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 47705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 52305
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 47605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 51705
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 47305
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 56005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 50405
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 60005
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 50305
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 59405
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 46405
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 55105
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 49505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 59105
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 49405
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 58505
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 30905
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 33505
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 33705
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 36605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 33605
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 36505
# TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 30005
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 32605
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 32805
-test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 35705
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 32705
+test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 35605
# TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 3358
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3358
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 3479
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 3479
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 3479
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 3479
# TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 5327
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 5327
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 5529
-test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 5529
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 5529
+test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 5529
# TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 68
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 68
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 73
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 73
+test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 73
+test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 73
# TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 387
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 387
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 392
-test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 392
+test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 388
+test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 388
# TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 15236
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 26249
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 15264
-test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 27281
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 15261
+test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 26278
# TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 21341
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 26354
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 21382
-test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 27399
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 21319
+test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 26336
# TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 9853
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 10003
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 10304
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 10454
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 10304
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 10454
# TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 1103
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1103
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 1104
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 1104
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 1104
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased_select_join x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 1104
# TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 4053
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 4203
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 4054
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 4204
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 4054
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 4204
# TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 95938
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 96088
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 103539
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 103689
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 103539
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 103689
# TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 93988
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 94138
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 101889
-test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 102039
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 101889
+test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 102039
# TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 496829
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 498671
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 528695
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 530537
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 527473
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 529315
# TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 425805
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 443405
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 431505
-test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 450605
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 432305
+test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 448205
# TEST: test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 21984
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 21984
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 22984
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 22984
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 22984
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 22984
# TEST: test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 102029
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 106786
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 106348
-test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 112356
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 106300
+test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 112058
# TEST: test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 19799
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 20301
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 20739
-test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 21307
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 20716
+test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 21244
# TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_load
-test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 1339
-test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1373
-test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 1399
-test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 1444
+test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 1453
+test.aaa_profiling.test_orm.MergeTest.test_merge_load x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 1502
# TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_no_load
-test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 101,17
-test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 101,17
-test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 103,18
-test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 103,18
+test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 103,18
+test.aaa_profiling.test_orm.MergeTest.test_merge_no_load x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 103,18
# TEST: test.aaa_profiling.test_orm.QueryTest.test_query_cols
-test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 5844
-test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6604
-test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 6152
-test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 6942
+test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 6142
+test.aaa_profiling.test_orm.QueryTest.test_query_cols x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 6932
# TEST: test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 251605
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 269605
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 262205
-test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 281705
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 262605
+test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 281605
# TEST: test.aaa_profiling.test_orm.SessionTest.test_expire_lots
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 1149
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1144
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 1269
-test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 1258
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 1259
+test.aaa_profiling.test_orm.SessionTest.test_expire_lots x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 1261
# TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect
-test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 90
-test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 90
-test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 74
-test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 74
+test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 74
+test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 74
# TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect
-test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 33
-test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 33
-test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 24
-test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 24
+test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 24
+test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 24
# TEST: test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 53
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 53
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 53
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 49
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 49
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 49
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 53
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 51
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 53
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 55
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 55
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 54
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 54
# TEST: test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 89
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 91
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 89
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 91
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 89
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 91
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 92
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 94
-test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 94
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 93
+test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 93
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 9
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 9
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 9
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 9
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 8
+test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 9
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 1583
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 13585
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 122534
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 134536
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 1576
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 13578
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 1535
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 13537
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 123501
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 135503
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 1541
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 43564
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 1551
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 13553
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 1489
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 13508
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 1584
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 13588
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 88324
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 100328
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 1577
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 13581
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 1572
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 13576
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 1525
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_legacy x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 13529
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 2586
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 15588
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 123537
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 136539
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 2579
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 15581
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 2542
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 15544
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 124508
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 137510
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 2548
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 45571
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 2554
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 15556
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 2492
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 15511
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 2588
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 15592
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 89328
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 102332
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 2581
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 15585
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 2576
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 15580
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 2529
-test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 15533
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 2570
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 15574
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 89310
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 102314
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 2563
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 2603
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 15607
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 2558
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 15562
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 2511
+test.aaa_profiling.test_resultset.ResultSetTest.test_fetch_by_key_mappings x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 15515
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0]
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 23
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 23
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 15
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 22
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 22
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-0] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 14
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1]
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 21
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 21
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 46
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 23
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 25
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 22
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 24
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 21
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 16
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 16
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-1] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 16
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2]
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 21
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 21
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 46
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 14
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 16
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 23
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 25
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 22
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 15
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 22
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 24
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 21
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 16
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 16
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 14
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[False-2] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 16
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1]
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 27
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 29
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 26
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 27
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 29
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 24
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 26
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 49
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 17
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 19
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 28
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 30
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 25
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 27
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 18
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 18
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 20
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 18
-test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 20
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 27
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 29
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 24
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 26
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 19
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 17
+test.aaa_profiling.test_resultset.ResultSetTest.test_one_or_none[True-1] x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 19
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 293
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 6313
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 121234
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 127234
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 252
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 6252
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 312
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 6332
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 122268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 128268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 380
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36420
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 263
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6283
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 233
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6253
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 6269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 87009
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 93009
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 237
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 6237
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 6259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 227
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 6227
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 267
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 6267
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 87007
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 93007
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 235
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 327
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 6327
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 6257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 225
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 6225
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 293
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 6313
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 121234
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 127234
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 252
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 6252
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 312
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 6332
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 122268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 128268
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 380
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36420
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 263
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6283
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 233
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6253
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 6269
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 87009
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 93009
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 237
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 6237
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 6259
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 227
-test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 6227
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 267
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 6267
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 87007
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 93007
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 235
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 327
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 6327
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 6257
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 225
+test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 6225
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_string
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 581
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 6583
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 121532
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 127534
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 574
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 6576
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 535
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 6537
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 122501
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 128503
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 550
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36570
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 549
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6551
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 487
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6506
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 583
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 6587
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 87323
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 93327
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 576
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 6580
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 571
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 6575
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 524
-test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 6528
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 563
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 6567
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 87303
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 93307
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 556
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 596
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 6600
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 551
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 6555
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 504
+test.aaa_profiling.test_resultset.ResultSetTest.test_string x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 6508
# TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_unicode
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_cextensions 581
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mariadb_mysqldb_dbapiunicode_nocextensions 6583
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_cextensions 121532
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mariadb_pymysql_dbapiunicode_nocextensions 127534
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_cextensions 574
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mssql_pyodbc_dbapiunicode_nocextensions 6576
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_cextensions 535
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mysql_mysqldb_dbapiunicode_nocextensions 6537
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_cextensions 122501
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_mysql_pymysql_dbapiunicode_nocextensions 128503
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_cextensions 550
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36570
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_cextensions 549
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6551
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_cextensions 487
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6506
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_cextensions 583
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mariadb_mysqldb_dbapiunicode_nocextensions 6587
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_cextensions 87323
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mariadb_pymysql_dbapiunicode_nocextensions 93327
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_cextensions 576
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_mssql_pyodbc_dbapiunicode_nocextensions 6580
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_cextensions 571
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_postgresql_psycopg2_dbapiunicode_nocextensions 6575
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_cextensions 524
-test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.9_sqlite_pysqlite_dbapiunicode_nocextensions 6528
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_cextensions 563
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_mariadb_mysqldb_dbapiunicode_nocextensions 6567
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_cextensions 87303
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_mariadb_pymysql_dbapiunicode_nocextensions 93307
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_mssql_pyodbc_dbapiunicode_cextensions 556
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_cextensions 596
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_oracle_cx_oracle_dbapiunicode_nocextensions 6600
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_cextensions 551
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_postgresql_psycopg2_dbapiunicode_nocextensions 6555
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_cextensions 504
+test.aaa_profiling.test_resultset.ResultSetTest.test_unicode x86_64_linux_cpython_3.10_sqlite_pysqlite_dbapiunicode_nocextensions 6508
def check(config):
if not against(config, "postgresql"):
return False
- count = (
- config.db.connect(close_with_result=True)
- .exec_driver_sql(
+ with config.db.connect() as conn:
+ count = conn.exec_driver_sql(
"SELECT count(*) FROM pg_extension "
"WHERE extname='%s'" % name
- )
- .scalar()
- )
+ ).scalar()
return bool(count)
return only_if(check, "needs %s extension" % name)
):
return False
try:
- config.db.connect(close_with_result=True).exec_driver_sql(
- "select '[1,2)'::int4range;"
- ).scalar()
+ with config.db.connect() as conn:
+ conn.exec_driver_sql("select '[1,2)'::int4range;").scalar()
return True
except Exception:
return False
if not against(config, "mysql"):
return False
- row = (
- config.db.connect(close_with_result=True)
- .exec_driver_sql("show variables like 'sql_mode'")
- .first()
- )
+ with config.db.connect() as conn:
+ row = conn.exec_driver_sql(
+ "show variables like 'sql_mode'"
+ ).first()
return not row or "NO_ZERO_DATE" not in row[1]
return only_if(check)
if not against(config, "mysql"):
return False
- row = (
- config.db.connect(close_with_result=True)
- .exec_driver_sql("show variables like 'sql_mode'")
- .first()
- )
+ with config.db.connect() as conn:
+ row = conn.exec_driver_sql(
+ "show variables like 'sql_mode'"
+ ).first()
return not row or "STRICT_TRANS_TABLES" not in row[1]
return only_if(check)
from sqlalchemy.sql import visitors
from sqlalchemy.sql.selectable import LABEL_STYLE_NONE
from sqlalchemy.sql.selectable import SelectStatementGrouping
-from sqlalchemy.testing import assert_raises
from sqlalchemy.testing import assert_raises_message
from sqlalchemy.testing import assertions
from sqlalchemy.testing import AssertsCompiledSQL
from sqlalchemy.testing import is_false
from sqlalchemy.testing import is_true
from sqlalchemy.testing import mock
-from sqlalchemy.testing import not_in
from sqlalchemy.testing.schema import Column
from sqlalchemy.testing.schema import Table
from sqlalchemy.util import compat
dict(b="a1", q="c1"),
)
- def test_column_label_overlap_fallback(self, connection):
- content, bar = self.tables.content, self.tables.bar
- row = connection.execute(
- select(content.c.type.label("content_type"))
- ).first()
-
- not_in(content.c.type, row)
- not_in(bar.c.content_type, row)
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(sql.column("content_type"), row)
-
- row = connection.execute(
- select(func.now().label("content_type"))
- ).first()
- not_in(content.c.type, row)
- not_in(bar.c.content_type, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(sql.column("content_type"), row)
-
- def test_columnclause_schema_column_one(self, connection):
- keyed2 = self.tables.keyed2
-
- # this is addressed by [ticket:2932]
- # ColumnClause._compare_name_for_result allows the
- # columns which the statement is against to be lightweight
- # cols, which results in a more liberal comparison scheme
- a, b = sql.column("a"), sql.column("b")
- stmt = select(a, b).select_from(table("keyed2"))
- row = connection.execute(stmt).first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.b, row)
-
- def test_columnclause_schema_column_two(self, connection):
- keyed2 = self.tables.keyed2
-
- a, b = sql.column("a"), sql.column("b")
- stmt = select(keyed2.c.a, keyed2.c.b)
- row = connection.execute(stmt).first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(b, row)
-
- def test_columnclause_schema_column_three(self, connection):
- keyed2 = self.tables.keyed2
-
- # originally addressed by [ticket:2932], however liberalized
- # Column-targeting rules are deprecated
-
- a, b = sql.column("a"), sql.column("b")
- stmt = text("select a, b from keyed2").columns(a=CHAR, b=CHAR)
- row = connection.execute(stmt).first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.b, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(b, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.b, row)
-
- def test_columnclause_schema_column_four(self, connection):
- keyed2 = self.tables.keyed2
-
- # this is also addressed by [ticket:2932]
-
- a, b = sql.column("keyed2_a"), sql.column("keyed2_b")
- stmt = text("select a AS keyed2_a, b AS keyed2_b from keyed2").columns(
- a, b
- )
- row = connection.execute(stmt).first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.b, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.keyed2_a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.keyed2_b, row)
-
- def test_columnclause_schema_column_five(self, connection):
- keyed2 = self.tables.keyed2
-
- # this is also addressed by [ticket:2932]
-
- stmt = text("select a AS keyed2_a, b AS keyed2_b from keyed2").columns(
- keyed2_a=CHAR, keyed2_b=CHAR
- )
- row = connection.execute(stmt).first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(keyed2.c.b, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.keyed2_a, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "The SelectBase.c and SelectBase.columns",
- ):
- in_(stmt.c.keyed2_b, row)
-
class PKIncrementTest(fixtures.TablesTest):
run_define_tables = "each"
self._test_autoincrement(conn)
-class ConnectionlessCursorResultTest(fixtures.TablesTest):
- __backend__ = True
-
- @classmethod
- def define_tables(cls, metadata):
- Table(
- "users",
- metadata,
- Column(
- "user_id", INT, primary_key=True, test_needs_autoincrement=True
- ),
- Column("user_name", VARCHAR(20)),
- test_needs_acid=True,
- )
-
- def test_connectionless_autoclose_rows_exhausted(self):
- users = self.tables.users
- with testing.db.begin() as conn:
- conn.execute(users.insert(), dict(user_id=1, user_name="john"))
-
- with testing.expect_deprecated_20(
- r"The (?:Executable|Engine)\.(?:execute|scalar)\(\) method"
- ):
- result = testing.db.execute(text("select * from users"))
- connection = result.connection
- assert not connection.closed
- eq_(result.fetchone(), (1, "john"))
- assert not connection.closed
- eq_(result.fetchone(), None)
- assert connection.closed
-
- @testing.requires.returning
- def test_connectionless_autoclose_crud_rows_exhausted(self):
- users = self.tables.users
- stmt = (
- users.insert()
- .values(user_id=1, user_name="john")
- .returning(users.c.user_id)
- )
- with testing.expect_deprecated_20(
- r"The (?:Executable|Engine)\.(?:execute|scalar)\(\) method"
- ):
- result = testing.db.execute(stmt)
- connection = result.connection
- assert not connection.closed
- eq_(result.fetchone(), (1,))
- assert not connection.closed
- eq_(result.fetchone(), None)
- assert connection.closed
-
- def test_connectionless_autoclose_no_rows(self):
- with testing.expect_deprecated_20(
- r"The (?:Executable|Engine)\.(?:execute|scalar)\(\) method"
- ):
- result = testing.db.execute(text("select * from users"))
- connection = result.connection
- assert not connection.closed
- eq_(result.fetchone(), None)
- assert connection.closed
-
- @testing.requires.updateable_autoincrement_pks
- def test_connectionless_autoclose_no_metadata(self):
- with testing.expect_deprecated_20(
- r"The (?:Executable|Engine)\.(?:execute|scalar)\(\) method"
- ):
- result = testing.db.execute(text("update users set user_id=5"))
- connection = result.connection
- assert connection.closed
-
- assert_raises_message(
- exc.ResourceClosedError,
- "This result object does not return rows.",
- result.fetchone,
- )
-
- with testing.expect_deprecated_20(
- r"Calling the .keys\(\) method on a result set that does not "
- ):
- eq_(result.keys(), [])
-
-
class CursorResultTest(fixtures.TablesTest):
__backend__ = True
],
)
- def test_column_accessor_textual_select(self, connection):
- users = self.tables.users
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names",
- "Using non-integer/slice indices on Row is "
- "deprecated and will be removed in version 2.0",
- ):
- # this will create column() objects inside
- # the select(), these need to match on name anyway
- r = connection.execute(
- select(column("user_id"), column("user_name"))
- .select_from(table("users"))
- .where(text("user_id=2"))
- ).first()
-
- eq_(r[users.c.user_id], 2)
-
- r._keymap.pop(users.c.user_id) # reset lookup
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(r._mapping[users.c.user_id], 2)
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(r._mapping[users.c.user_name], "jack")
-
- def test_keys_no_rows(self, connection):
-
- for i in range(2):
- r = connection.execute(
- text("update users set user_name='new' where user_id=10")
- )
-
- with testing.expect_deprecated(
- r"Calling the .keys\(\) method on a result set that does not "
- r"return rows is deprecated and will raise "
- r"ResourceClosedError in SQLAlchemy 2.0."
- ):
- list_ = r.keys()
- eq_(list_, [])
- list_.append("Don't cache me")
-
- def test_column_accessor_basic_text(self, connection):
- users = self.tables.users
-
- with testing.expect_deprecated(
- "Using non-integer/slice indices on Row is deprecated "
- "and will be removed in version 2.0",
- "Retrieving row values using Column objects "
- "with only matching names",
- ):
- r = connection.execute(
- text("select * from users where user_id=2")
- ).first()
-
- eq_(r[users.c.user_id], 2)
-
- r._keymap.pop(users.c.user_id)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(r._mapping[users.c.user_id], 2)
-
- with testing.expect_deprecated(
- "Using non-integer/slice indices on Row is deprecated "
- "and will be removed in version 2.0",
- "Retrieving row values using Column objects "
- "with only matching names",
- ):
- eq_(r[users.c.user_name], "jack")
-
- r._keymap.pop(users.c.user_name)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(r._mapping[users.c.user_name], "jack")
-
- @testing.provide_metadata
- def test_column_label_overlap_fallback(self, connection):
- content = Table("content", self.metadata, Column("type", String(30)))
- bar = Table("bar", self.metadata, Column("content_type", String(30)))
- self.metadata.create_all(testing.db)
- connection.execute(content.insert().values(type="t1"))
-
- row = connection.execute(
- content.select().set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL)
- ).first()
- in_(content.c.type, row._mapping)
- not_in(bar.c.content_type, row)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(sql.column("content_type"), row)
-
- row = connection.execute(
- select(content.c.type.label("content_type"))
- ).first()
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(content.c.type, row)
-
- not_in(bar.c.content_type, row)
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(sql.column("content_type"), row)
-
- row = connection.execute(
- select(func.now().label("content_type"))
- ).first()
-
- not_in(content.c.type, row)
-
- not_in(bar.c.content_type, row)
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- in_(sql.column("content_type"), row)
-
- def test_pickled_rows(self):
- users = self.tables.users
- addresses = self.tables.addresses
- with testing.db.begin() as conn:
- conn.execute(users.delete())
- conn.execute(
- users.insert(),
- [
- {"user_id": 7, "user_name": "jack"},
- {"user_id": 8, "user_name": "ed"},
- {"user_id": 9, "user_name": "fred"},
- ],
- )
-
- for pickle in False, True:
- for use_labels in False, True:
- stmt = users.select()
- if use_labels:
- stmt = stmt.set_label_style(
- LABEL_STYLE_TABLENAME_PLUS_COL
- )
-
- result = conn.execute(
- stmt.order_by(users.c.user_id)
- ).fetchall()
-
- if pickle:
- result = util.pickle.loads(util.pickle.dumps(result))
-
- if pickle:
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[users.c.user_id], 7)
-
- result[0]._keymap.pop(users.c.user_id)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[users.c.user_id], 7)
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[users.c.user_name], "jack")
-
- result[0]._keymap.pop(users.c.user_name)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[users.c.user_name], "jack")
-
- if not pickle or use_labels:
- assert_raises(
- exc.NoSuchColumnError,
- lambda: result[0][addresses.c.user_id],
- )
-
- assert_raises(
- exc.NoSuchColumnError,
- lambda: result[0]._mapping[addresses.c.user_id],
- )
- else:
- # test with a different table. name resolution is
- # causing 'user_id' to match when use_labels wasn't
- # used.
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[addresses.c.user_id], 7)
-
- result[0]._keymap.pop(addresses.c.user_id)
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "from a row that was unpickled"
- ):
- eq_(result[0]._mapping[addresses.c.user_id], 7)
-
- assert_raises(
- exc.NoSuchColumnError,
- lambda: result[0][addresses.c.address_id],
- )
-
- assert_raises(
- exc.NoSuchColumnError,
- lambda: result[0]._mapping[addresses.c.address_id],
- )
-
@testing.requires.duplicate_names_in_cursor_description
def test_ambiguous_column_case_sensitive(self):
with testing.expect_deprecated(
lambda: row._mapping["somecol"],
)
- def test_row_getitem_string(self, connection):
- col = literal_column("1").label("foo")
-
- with testing.expect_deprecated(
- "Using non-integer/slice indices on Row is deprecated "
- "and will be removed in version 2.0;"
- ):
- row = connection.execute(select(col)).first()
- eq_(row["foo"], 1)
-
- eq_(row._mapping["foo"], 1)
-
- def test_row_getitem_column(self, connection):
- col = literal_column("1").label("foo")
-
- with testing.expect_deprecated(
- "Using non-integer/slice indices on Row is deprecated "
- "and will be removed in version 2.0;"
- ):
- row = connection.execute(select(col)).first()
- eq_(row[col], 1)
-
- eq_(row._mapping[col], 1)
-
def test_row_case_insensitive(self):
with testing.expect_deprecated(
"The create_engine.case_sensitive parameter is deprecated"
eq_(row._mapping["casesensitive"], 2)
eq_(row._mapping["screw_UP_the_cols"], 3)
- def test_row_keys_deprecated(self, connection):
- r = connection.execute(
- text("select * from users where user_id=2")
- ).first()
-
- with testing.expect_deprecated_20(
- r"The Row.keys\(\) method is considered legacy "
- ):
- eq_(r.keys(), ["user_id", "user_name"])
-
- def test_row_contains_key_deprecated(self, connection):
- r = connection.execute(
- text("select * from users where user_id=2")
- ).first()
-
- with testing.expect_deprecated(
- "Using the 'in' operator to test for string or column keys, or "
- "integer indexes, .* is deprecated"
- ):
- in_("user_name", r)
-
- # no warning if the key is not there
- not_in("foobar", r)
-
- # this seems to happen only with Python BaseRow
- # with testing.expect_deprecated(
- # "Using the 'in' operator to test for string or column keys, or "
- # "integer indexes, .* is deprecated"
- # ):
- # in_(1, r)
-
-
-class PositionalTextTest(fixtures.TablesTest):
- run_inserts = "once"
- run_deletes = None
- __backend__ = True
-
- @classmethod
- def define_tables(cls, metadata):
- Table(
- "text1",
- metadata,
- Column("a", CHAR(2)),
- Column("b", CHAR(2)),
- Column("c", CHAR(2)),
- Column("d", CHAR(2)),
- )
-
- @classmethod
- def insert_data(cls, connection):
- connection.execute(
- cls.tables.text1.insert(),
- [dict(a="a1", b="b1", c="c1", d="d1")],
- )
-
- def test_anon_aliased_overlapping(self, connection):
- text1 = self.tables.text1
-
- c1 = text1.c.a.label(None)
- c2 = text1.alias().c.a
- c3 = text1.alias().c.a.label(None)
- c4 = text1.c.a.label(None)
-
- stmt = text("select a, b, c, d from text1").columns(c1, c2, c3, c4)
- result = connection.execute(stmt)
- row = result.first()
-
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(row._mapping[text1.c.a], "a1")
-
- def test_anon_aliased_unique(self, connection):
- text1 = self.tables.text1
-
- c1 = text1.c.a.label(None)
- c2 = text1.alias().c.c
- c3 = text1.alias().c.b
- c4 = text1.alias().c.d.label(None)
-
- stmt = text("select a, b, c, d from text1").columns(c1, c2, c3, c4)
- result = connection.execute(stmt)
- row = result.first()
-
- eq_(row._mapping[c1], "a1")
- eq_(row._mapping[c2], "b1")
- eq_(row._mapping[c3], "c1")
- eq_(row._mapping[c4], "d1")
-
- # key fallback rules still match this to a column
- # unambiguously based on its name
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(row._mapping[text1.c.a], "a1")
-
- # key fallback rules still match this to a column
- # unambiguously based on its name
- with testing.expect_deprecated(
- "Retrieving row values using Column objects "
- "with only matching names"
- ):
- eq_(row._mapping[text1.c.d], "d1")
-
- # text1.c.b goes nowhere....because we hit key fallback
- # but the text1.c.b doesn't derive from text1.c.c
- assert_raises_message(
- exc.NoSuchColumnError,
- "Could not locate column in row for column 'text1.b'",
- lambda: row[text1.c.b],
- )
-
- assert_raises_message(
- exc.NoSuchColumnError,
- "Could not locate column in row for column 'text1.b'",
- lambda: row._mapping[text1.c.b],
- )
-
class DefaultTest(fixtures.TestBase):
__backend__ = True
assert _op_modern == _op_legacy
-class LegacySequenceExecTest(fixtures.TestBase):
- __requires__ = ("sequences",)
- __backend__ = True
-
- @classmethod
- def setup_test_class(cls):
- cls.seq = Sequence("my_sequence")
- cls.seq.create(testing.db)
-
- @classmethod
- def teardown_test_class(cls):
- cls.seq.drop(testing.db)
-
- def _assert_seq_result(self, ret):
- """asserts return of next_value is an int"""
-
- assert isinstance(ret, util.int_types)
- assert ret >= testing.db.dialect.default_sequence_base
-
- def test_implicit_connectionless(self):
- with testing.expect_deprecated_20(
- r"The MetaData.bind argument is deprecated"
- ):
- s = Sequence("my_sequence", metadata=MetaData(testing.db))
-
- with testing.expect_deprecated_20(
- r"The DefaultGenerator.execute\(\) method is considered legacy "
- "as of the 1.x",
- ):
- self._assert_seq_result(s.execute())
-
- def test_explicit(self, connection):
- s = Sequence("my_sequence")
- with testing.expect_deprecated_20(
- r"The DefaultGenerator.execute\(\) method is considered legacy"
- ):
- self._assert_seq_result(s.execute(connection))
-
- def test_explicit_optional(self):
- """test dialect executes a Sequence, returns nextval, whether
- or not "optional" is set"""
-
- s = Sequence("my_sequence", optional=True)
- with testing.expect_deprecated_20(
- r"The DefaultGenerator.execute\(\) method is considered legacy"
- ):
- self._assert_seq_result(s.execute(testing.db))
-
- def test_func_implicit_connectionless_execute(self):
- """test func.next_value().execute()/.scalar() works
- with connectionless execution."""
-
- with testing.expect_deprecated_20(
- r"The MetaData.bind argument is deprecated"
- ):
- s = Sequence("my_sequence", metadata=MetaData(testing.db))
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
- ):
- self._assert_seq_result(s.next_value().execute().scalar())
-
- def test_func_explicit(self):
- s = Sequence("my_sequence")
- with testing.expect_deprecated_20(
- r"The Engine.scalar\(\) method is considered legacy"
- ):
- self._assert_seq_result(testing.db.scalar(s.next_value()))
-
- def test_func_implicit_connectionless_scalar(self):
- """test func.next_value().execute()/.scalar() works."""
-
- with testing.expect_deprecated_20(
- r"The MetaData.bind argument is deprecated"
- ):
- s = Sequence("my_sequence", metadata=MetaData(testing.db))
- with testing.expect_deprecated_20(
- r"The Executable.execute\(\) method is considered legacy"
- ):
- self._assert_seq_result(s.next_value().scalar())
-
- def test_func_embedded_select(self):
- """test can use next_value() in select column expr"""
-
- s = Sequence("my_sequence")
- with testing.expect_deprecated_20(
- r"The Engine.scalar\(\) method is considered legacy"
- ):
- self._assert_seq_result(testing.db.scalar(select(s.next_value())))
-
-
class DDLDeprecatedBindTest(fixtures.TestBase):
def teardown_test(self):
with testing.db.begin() as conn:
from sqlalchemy.engine import Row
from sqlalchemy.engine.result import SimpleResultMetaData
from sqlalchemy.engine.row import KEY_INTEGER_ONLY
-from sqlalchemy.engine.row import KEY_OBJECTS_BUT_WARN
-from sqlalchemy.engine.row import LegacyRow
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql import ColumnElement
from sqlalchemy.sql import expression
from sqlalchemy.testing import assertions
from sqlalchemy.testing import engines
from sqlalchemy.testing import eq_
+from sqlalchemy.testing import expect_raises
from sqlalchemy.testing import expect_raises_message
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import in_
test_needs_acid=True,
)
+ def test_keys_no_rows(self, connection):
+
+ for i in range(2):
+ r = connection.execute(
+ text("update users set user_name='new' where user_id=10")
+ )
+
+ with expect_raises_message(
+ exc.ResourceClosedError,
+ "This result object does not return rows",
+ ):
+ r.keys()
+
+ def test_row_keys_removed(self, connection):
+ r = connection.execute(
+ text("select * from users where user_id=2")
+ ).first()
+
+ with expect_raises(AttributeError):
+ r.keys()
+
+ def test_row_contains_key_no_strings(self, connection):
+ users = self.tables.users
+
+ connection.execute(
+ users.insert(),
+ [
+ dict(user_id=1, user_name="john"),
+ dict(user_id=2, user_name="jack"),
+ ],
+ )
+
+ r = connection.execute(
+ text("select * from users where user_id=2")
+ ).first()
+
+ not_in("user_name", r)
+ in_("user_name", r._mapping)
+ not_in("foobar", r)
+ not_in("foobar", r._mapping)
+
def test_row_iteration(self, connection):
users = self.tables.users
in_(content.c.type, row._mapping)
not_in(bar.c.content_type, row._mapping)
+ # in 1.x, would warn for string match, but return a result
+ not_in(sql.column("content_type"), row)
+
not_in(bar.c.content_type, row._mapping)
row = connection.execute(
not_in(bar.c.content_type, row._mapping)
+ # in 1.x, would warn for string match, but return a result
+ not_in(sql.column("content_type"), row._mapping)
+
def test_pickled_rows(self, connection):
users = self.tables.users
+ addresses = self.tables.addresses
connection.execute(
users.insert(),
eq_(result[0][0], 7)
assert_raises(
- exc.NoSuchColumnError, lambda: result[0]["fake key"]
+ exc.NoSuchColumnError,
+ lambda: result[0]._mapping["fake key"],
)
+ # previously would warn
+
+ if pickle:
+ with expect_raises_message(
+ exc.NoSuchColumnError,
+ "Row was unpickled; lookup by ColumnElement is "
+ "unsupported",
+ ):
+ result[0]._mapping[users.c.user_id]
+ else:
+ eq_(result[0]._mapping[users.c.user_id], 7)
+
+ if pickle:
+ with expect_raises_message(
+ exc.NoSuchColumnError,
+ "Row was unpickled; lookup by ColumnElement is "
+ "unsupported",
+ ):
+ result[0]._mapping[users.c.user_name]
+ else:
+ eq_(result[0]._mapping[users.c.user_name], "jack")
+
assert_raises(
exc.NoSuchColumnError,
- lambda: result[0]._mapping["fake key"],
+ lambda: result[0]._mapping[addresses.c.user_id],
+ )
+
+ assert_raises(
+ exc.NoSuchColumnError,
+ lambda: result[0]._mapping[addresses.c.address_id],
)
def test_column_error_printing(self, connection):
text("select * from users where user_id=2")
).first()
+ with expect_raises_message(TypeError, "tuple indices must be"):
+ r["foo"]
+
eq_(r._mapping["user_name"], "jack")
+ def test_row_getitem_column(self, connection):
+ col = literal_column("1").label("foo")
+
+ row = connection.execute(select(col)).first()
+
+ with expect_raises_message(TypeError, "tuple indices must be"):
+ row[col]
+
+ eq_(row._mapping[col], 1)
+
def test_column_accessor_basic_text(self, connection):
users = self.tables.users
eq_(r.user_name, "jack")
eq_(r._mapping["user_name"], "jack")
+ # cases which used to succeed w warning
+ with expect_raises_message(
+ exc.NoSuchColumnError, "Could not locate column in row"
+ ):
+ r._mapping[users.c.user_id]
+ with expect_raises_message(
+ exc.NoSuchColumnError, "Could not locate column in row"
+ ):
+ r._mapping[users.c.user_name]
+
def test_column_accessor_text_colexplicit(self, connection):
users = self.tables.users
eq_(r.user_name, "jack")
eq_(r._mapping["user_name"], "jack")
+ # error cases that previously would warn
+ with expect_raises_message(
+ exc.NoSuchColumnError, "Could not locate column in row"
+ ):
+ r._mapping[users.c.user_id]
+ with expect_raises_message(
+ exc.NoSuchColumnError, "Could not locate column in row"
+ ):
+ r._mapping[users.c.user_name]
+
def test_column_accessor_dotted_union(self, connection):
users = self.tables.users
lambda: r._mapping["foo"],
)
- @testing.combinations(
- (True,),
- (False,),
- argnames="future",
- )
- def test_graceful_fetch_on_non_rows(self, future):
+ def test_graceful_fetch_on_non_rows(self):
"""test that calling fetchone() etc. on a result that doesn't
return rows fails gracefully.
users = self.tables.users
conn = testing.db.connect()
- if future:
- conn = conn.execution_options(future_result=True)
keys_lambda = lambda r: r.keys() # noqa: E731
for meth in [
trans = conn.begin()
result = conn.execute(users.insert(), dict(user_id=1))
- if not future and meth is keys_lambda:
- with testing.expect_deprecated(
- r"Calling the .keys\(\) method on a result set that does "
- r"not return rows is deprecated"
- ):
- eq_(meth(result), [])
- else:
- assert_raises_message(
- exc.ResourceClosedError,
- "This result object does not return rows. "
- "It has been closed automatically.",
- meth,
- result,
- )
+ assert_raises_message(
+ exc.ResourceClosedError,
+ "This result object does not return rows. "
+ "It has been closed automatically.",
+ meth,
+ result,
+ )
trans.rollback()
def test_fetchone_til_end(self, connection):
(lambda result: result.first()._mapping),
argnames="get_object",
)
- @testing.combinations(
- (True,),
- (False,),
- argnames="future",
- )
- def test_keys(self, connection, get_object, future):
+ def test_keys(self, connection, get_object):
users = self.tables.users
addresses = self.tables.addresses
- if future:
- connection = connection.execution_options(future_result=True)
-
connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
result = connection.execute(users.select())
obj = get_object(result)
- # Row still has a .keys() method as well as LegacyRow
- # as in 1.3.x, the KeyedTuple object also had a keys() method.
- # it emits a 2.0 deprecation warning.
if isinstance(obj, Row):
- with assertions.expect_deprecated_20("The Row.keys()"):
- keys = obj.keys()
+ keys = obj._mapping.keys()
else:
keys = obj.keys()
eq_(list(row._mapping.keys()), ["user_id", "user_name"])
eq_(row._fields, ("user_id", "user_name"))
- with assertions.expect_deprecated_20("The Row.keys()"):
- in_("user_id", row.keys())
- with assertions.expect_deprecated_20("The Row.keys()"):
- not_in("foo", row.keys())
- with assertions.expect_deprecated_20("The Row.keys()"):
- in_(users.c.user_id, row.keys())
+ in_("user_id", row._fields)
+ not_in("foo", row._fields)
+ in_(users.c.user_id, row._mapping.keys())
def test_row_keys_legacy_dont_warn(self, connection):
users = self.tables.users
connection.execute(users.insert(), dict(user_id=1, user_name="foo"))
result = connection.execute(users.select())
row = result.first()
- # DO NOT WARN DEPRECATED IN 1.x, ONLY 2.0 WARNING
- with assertions.expect_deprecated_20("The Row.keys()"):
- eq_(dict(row), {"user_id": 1, "user_name": "foo"})
+ eq_(dict(row._mapping), {"user_id": 1, "user_name": "foo"})
- with assertions.expect_deprecated_20("The Row.keys()"):
- eq_(row.keys(), ["user_id", "user_name"])
+ eq_(row._fields, ("user_id", "user_name"))
def test_row_namedtuple_legacy_ok(self, connection):
users = self.tables.users
)
is_true(isinstance(row, collections_abc.Sequence))
- @testing.combinations((Row,), (LegacyRow,))
- def test_row_special_names(self, row_cls):
+ def test_row_special_names(self):
metadata = SimpleResultMetaData(["key", "count", "index", "foo"])
- row = row_cls(
+ row = Row(
metadata,
[None, None, None, None],
metadata._keymap,
- row_cls._default_key_style,
+ Row._default_key_style,
["kv", "cv", "iv", "f"],
)
is_true(isinstance(row, collections_abc.Sequence))
eq_(row.count, "cv")
eq_(row.index, "iv")
- with assertions.expect_deprecated_20(
- "Retrieving row members using strings or other non-integers "
- "is deprecated; use row._mapping for a dictionary interface "
- "to the row"
- ):
- eq_(row["foo"], "f")
- eq_(row["count"], "cv")
- eq_(row["index"], "iv")
-
+ eq_(row._mapping["foo"], "f")
eq_(row._mapping["count"], "cv")
eq_(row._mapping["index"], "iv")
metadata = SimpleResultMetaData(["key", "q", "p"])
- row = row_cls(
+ row = Row(
metadata,
[None, None, None],
metadata._keymap,
eq_(row.count("cv"), 1)
eq_(row.count("x"), 0)
- @testing.combinations((Row,), (LegacyRow,))
- def test_row_dict_behaviors_warn_mode(self, row_cls):
- metadata = SimpleResultMetaData(
- [
- "a",
- "b",
- "count",
- ]
- )
- row = row_cls(
- metadata,
- [None, None, None],
- metadata._keymap,
- KEY_OBJECTS_BUT_WARN,
- ["av", "bv", "cv"],
- )
-
- # as of #6218, dict(row) and row["x"] work for
- # both LegacyRow and Row, with 2.0 deprecation warnings
- # for both
- with assertions.expect_deprecated_20(
- "Retrieving row members using strings or other non-integers "
- "is deprecated; use row._mapping for a dictionary interface "
- "to the row"
- ):
- eq_(dict(row), {"a": "av", "b": "bv", "count": "cv"})
-
- with assertions.expect_deprecated_20(
- "Retrieving row members using strings or other non-integers "
- "is deprecated; use row._mapping for a dictionary interface "
- "to the row"
- ):
- eq_(row["a"], "av")
- eq_(row["count"], "cv")
-
- # keys is keys
- with assertions.expect_deprecated_20("The Row.keys()"):
- eq_(list(row.keys()), ["a", "b", "count"])
-
def test_new_row_no_dict_behaviors(self):
"""This mode is not used currently but will be once we are in 2.0."""
metadata = SimpleResultMetaData(
["av", "bv", "cv"],
)
- with assertions.expect_raises_message(
- TypeError,
- "TypeError: tuple indices must be integers or slices, not str",
- ):
- with assertions.expect_deprecated_20("The Row.keys()"):
- eq_(dict(row), {"a": "av", "b": "bv", "count": "cv"})
+ eq_(dict(row._mapping), {"a": "av", "b": "bv", "count": "cv"})
with assertions.expect_raises_message(
TypeError,
):
eq_(row["count"], "cv")
- # keys is keys
- with assertions.expect_deprecated_20("The Row.keys()"):
- eq_(list(row.keys()), ["a", "b", "count"])
+ eq_(list(row._mapping), ["a", "b", "count"])
def test_row_is_hashable(self):
eq_(row.keyed2_a, "a2")
eq_(row.keyed2_b, "b2")
- assert_raises(KeyError, lambda: row["keyed2_c"])
- assert_raises(KeyError, lambda: row["keyed2_q"])
assert_raises(KeyError, lambda: row._mapping["keyed2_c"])
assert_raises(KeyError, lambda: row._mapping["keyed2_q"])
in_(a, row._mapping)
in_(b, row._mapping)
+ keyed2 = self.tables.keyed2
+
+ not_in(keyed2.c.a, row._mapping)
+ not_in(keyed2.c.b, row._mapping)
+
def test_columnclause_schema_column_two(self, connection):
keyed2 = self.tables.keyed2
in_(keyed2.c.a, row._mapping)
in_(keyed2.c.b, row._mapping)
+ # in 1.x, would warn for string match, but return a result
+ a, b = sql.column("a"), sql.column("b")
+ not_in(a, row._mapping)
+ not_in(b, row._mapping)
+
def test_columnclause_schema_column_three(self, connection):
# this is also addressed by [ticket:2932]
stmt = text("select a, b from keyed2").columns(a=CHAR, b=CHAR)
in_(stmt.selected_columns.a, row._mapping)
in_(stmt.selected_columns.b, row._mapping)
+ keyed2 = self.tables.keyed2
+ a, b = sql.column("a"), sql.column("b")
+
+ # in 1.x, would warn for string match, but return a result
+ not_in(keyed2.c.a, row._mapping)
+ not_in(keyed2.c.b, row._mapping)
+ not_in(a, row._mapping)
+ not_in(b, row._mapping)
+ not_in(stmt.subquery().c.a, row._mapping)
+ not_in(stmt.subquery().c.b, row._mapping)
+
def test_columnclause_schema_column_four(self, connection):
# originally addressed by [ticket:2932], however liberalized
# Column-targeting rules are deprecated
in_(stmt.selected_columns.keyed2_a, row._mapping)
in_(stmt.selected_columns.keyed2_b, row._mapping)
+ keyed2 = self.tables.keyed2
+
+ # in 1.x, would warn for string match, but return a result
+ not_in(keyed2.c.a, row._mapping)
+ not_in(keyed2.c.b, row._mapping)
+ not_in(stmt.subquery().c.keyed2_a, row._mapping)
+ not_in(stmt.subquery().c.keyed2_b, row._mapping)
+
def test_columnclause_schema_column_five(self, connection):
# this is also addressed by [ticket:2932]
in_(stmt.selected_columns.keyed2_a, row._mapping)
in_(stmt.selected_columns.keyed2_b, row._mapping)
+ keyed2 = self.tables.keyed2
+
+ # in 1.x, would warn for string match, but return a result
+ not_in(keyed2.c.a, row._mapping)
+ not_in(keyed2.c.b, row._mapping)
+ not_in(stmt.subquery().c.keyed2_a, row._mapping)
+ not_in(stmt.subquery().c.keyed2_b, row._mapping)
+
def _adapt_result_columns_fixture_one(self):
keyed1 = self.tables.keyed1
stmt = (
cache = {}
result = connection._execute_20(
stmt1,
- execution_options={"compiled_cache": cache, "future_result": True},
+ execution_options={"compiled_cache": cache},
)
result.close()
assert cache
result = connection._execute_20(
stmt2,
- execution_options={"compiled_cache": cache, "future_result": True},
+ execution_options={"compiled_cache": cache},
)
row = result.first()
eq_(row._mapping[c3], "c1")
eq_(row._mapping[c4], "d1")
+ # in 1.x, would warn for string match, but return a result
+ assert_raises_message(
+ exc.NoSuchColumnError,
+ "Could not locate column in row for column 'text1.a'",
+ lambda: row._mapping[text1.c.a],
+ )
+
+ # in 1.x, would warn for string match, but return a result
+ assert_raises_message(
+ exc.NoSuchColumnError,
+ "Could not locate column in row for column 'text1.d'",
+ lambda: row._mapping[text1.c.d],
+ )
+
# text1.c.b goes nowhere....because we hit key fallback
# but the text1.c.b doesn't derive from text1.c.c
assert_raises_message(
eq_(row._mapping[c3], "c1")
eq_(row._mapping[c4], "d1")
+ # in 1.x, would warn for string match, but return a result
+ assert_raises_message(
+ exc.NoSuchColumnError,
+ "Could not locate column in row for column 'text1.a'",
+ lambda: row._mapping[text1.c.a],
+ )
+
def test_anon_aliased_name_conflict(self, connection):
text1 = self.tables.text1
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
