From aa026c302c6b188a7e28508f9ecb603809b9e03f Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Sat, 30 Oct 2021 14:44:55 -0400 Subject: [PATCH] 2.0 removals: LegacyRow, connectionless execution, close_with_result in order to remove LegacyRow / LegacyResult, we have to also lose close_with_result, which connectionless execution relies upon. also includes a new profiles.txt file that's all against py310, as that's what CI is on now. some result counts changed by one function call which was enough to fail the low-count result tests. Replaces Connectable as the common interface between Connection and Engine with EngineEventsTarget. Engine is no longer Connectable. Connection and MockConnection still are. References: #7257 Change-Id: Iad5eba0313836d347e65490349a22b061356896a --- doc/build/core/pooling.rst | 8 - lib/sqlalchemy/cextension/resultproxy.c | 14 +- lib/sqlalchemy/engine/__init__.py | 2 - lib/sqlalchemy/engine/base.py | 137 +--- lib/sqlalchemy/engine/cursor.py | 243 +----- lib/sqlalchemy/engine/default.py | 41 +- lib/sqlalchemy/engine/events.py | 9 +- lib/sqlalchemy/engine/interfaces.py | 57 +- lib/sqlalchemy/engine/mock.py | 24 +- lib/sqlalchemy/engine/result.py | 21 +- lib/sqlalchemy/engine/row.py | 210 +---- lib/sqlalchemy/sql/base.py | 40 - lib/sqlalchemy/sql/compiler.py | 2 + lib/sqlalchemy/sql/schema.py | 13 - lib/sqlalchemy/testing/assertions.py | 6 +- lib/sqlalchemy/testing/profiling.py | 7 +- lib/sqlalchemy/testing/suite/test_select.py | 4 +- regen_callcounts.tox.ini | 2 +- test/aaa_profiling/test_memusage.py | 19 - test/aaa_profiling/test_resultset.py | 41 +- test/engine/test_deprecations.py | 175 +--- test/engine/test_reconnect.py | 84 +- test/orm/test_deprecations.py | 77 -- test/profiles.txt | 834 ++++++-------------- test/requirements.py | 32 +- test/sql/test_deprecations.py | 720 ----------------- test/sql/test_resultset.py | 311 +++++--- 27 files changed, 621 insertions(+), 2512 deletions(-) diff --git a/doc/build/core/pooling.rst b/doc/build/core/pooling.rst index 878a9ccab6..858f8b0f5a 100644 --- a/doc/build/core/pooling.rst +++ b/doc/build/core/pooling.rst @@ -270,11 +270,6 @@ behaviors are needed:: # 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 @@ -294,9 +289,6 @@ behaviors are needed:: 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 diff --git a/lib/sqlalchemy/cextension/resultproxy.c b/lib/sqlalchemy/cextension/resultproxy.c index 2de672f22b..99b2d36f33 100644 --- a/lib/sqlalchemy/cextension/resultproxy.c +++ b/lib/sqlalchemy/cextension/resultproxy.c @@ -55,8 +55,6 @@ static PyObject *sqlalchemy_engine_result = NULL; 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 * @@ -409,16 +407,6 @@ BaseRow_getitem_by_object(BaseRow *self, PyObject *key, int asmapping) /* -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); } @@ -503,7 +491,7 @@ BaseRow_subscript(BaseRow *self, PyObject *key) 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 { diff --git a/lib/sqlalchemy/engine/__init__.py b/lib/sqlalchemy/engine/__init__.py index 6306e201d0..ba57eee51d 100644 --- a/lib/sqlalchemy/engine/__init__.py +++ b/lib/sqlalchemy/engine/__init__.py @@ -31,7 +31,6 @@ from .cursor import BufferedColumnRow 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 @@ -52,7 +51,6 @@ from .result import Result 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 diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py index 2444b5c7fe..c60a8383fa 100644 --- a/lib/sqlalchemy/engine/base.py +++ b/lib/sqlalchemy/engine/base.py @@ -10,6 +10,7 @@ import contextlib 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 @@ -64,11 +65,15 @@ class Connection(Connectable): # 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, @@ -86,7 +91,6 @@ class Connection(Connectable): 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: @@ -99,7 +103,6 @@ class Connection(Connectable): 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() @@ -169,8 +172,7 @@ class Connection(Connectable): 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 @@ -590,7 +592,9 @@ class Connection(Connectable): 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 @@ -1333,8 +1337,6 @@ class Connection(Connectable): 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( @@ -1684,7 +1686,6 @@ class Connection(Connectable): """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 @@ -1705,6 +1706,7 @@ class Connection(Connectable): self._handle_dbapi_exception( e, util.text_type(statement), parameters, None, None ) + return # not reached if ( self._transaction @@ -1815,10 +1817,6 @@ class Connection(Connectable): 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 @@ -1828,16 +1826,6 @@ class Connection(Connectable): ): 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 @@ -2035,9 +2023,6 @@ class Connection(Connectable): 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): @@ -2710,7 +2695,7 @@ class TwoPhaseTransaction(RootTransaction): 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 @@ -2965,10 +2950,9 @@ class Engine(Connectable, log.Identified): 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__() @@ -2978,10 +2962,9 @@ class Engine(Connectable, log.Identified): 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. @@ -2997,15 +2980,6 @@ class Engine(Connectable, log.Identified): 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 @@ -3016,16 +2990,13 @@ class Engine(Connectable, log.Identified): 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", @@ -3106,77 +3077,7 @@ class Engine(Connectable, log.Identified): 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 @@ -3191,7 +3092,7 @@ class Engine(Connectable, log.Identified): """ - return self._connection_cls(self, close_with_result=close_with_result) + return self._connection_cls(self) @util.deprecated( "1.4", diff --git a/lib/sqlalchemy/engine/cursor.py b/lib/sqlalchemy/engine/cursor.py index 5e6078f866..049422617d 100644 --- a/lib/sqlalchemy/engine/cursor.py +++ b/lib/sqlalchemy/engine/cursor.py @@ -16,10 +16,10 @@ from .result import Result 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 @@ -53,7 +53,8 @@ class CursorResultMetaData(ResultMetaData): "_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. ) @@ -82,6 +83,7 @@ class CursorResultMetaData(ResultMetaData): 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 @@ -143,6 +145,7 @@ class CursorResultMetaData(ResultMetaData): 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 @@ -158,7 +161,7 @@ class CursorResultMetaData(ResultMetaData): 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: ( @@ -610,14 +613,34 @@ class CursorResultMetaData(ResultMetaData): ) 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 @@ -694,7 +717,7 @@ class CursorResultMetaData(ResultMetaData): } 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) @@ -702,116 +725,6 @@ class CursorResultMetaData(ResultMetaData): 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[], 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. @@ -1205,19 +1118,7 @@ class _NoResultMetaData(ResultMetaData): 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): @@ -1750,10 +1651,9 @@ 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. @@ -1762,14 +1662,6 @@ class CursorResult(BaseCursorResult, Result): 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 @@ -1839,62 +1731,7 @@ class CursorResult(BaseCursorResult, Result): 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): @@ -1919,7 +1756,7 @@ class FullyBufferedResultProxy(ResultProxy): _cursor_strategy_cls = FullyBufferedCursorFetchStrategy -class BufferedColumnRow(LegacyRow): +class BufferedColumnRow(Row): """Row is now BufferedColumn in all cases""" diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py index 75bca19050..002203ddcb 100644 --- a/lib/sqlalchemy/engine/default.py +++ b/lib/sqlalchemy/engine/default.py @@ -855,7 +855,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext): _is_implicit_returning = False _is_explicit_returning = False - _is_future_result = False _is_server_side = False _soft_closed = False @@ -890,11 +889,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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( @@ -947,11 +941,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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, @@ -1106,11 +1095,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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()] @@ -1157,11 +1141,6 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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 @@ -1420,18 +1399,7 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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 @@ -1493,12 +1461,7 @@ class DefaultExecutionContext(interfaces.ExecutionContext): 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: diff --git a/lib/sqlalchemy/engine/events.py b/lib/sqlalchemy/engine/events.py index f091c7733a..effebb4cbf 100644 --- a/lib/sqlalchemy/engine/events.py +++ b/lib/sqlalchemy/engine/events.py @@ -7,20 +7,21 @@ 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 @@ -90,7 +91,7 @@ class ConnectionEvents(event.Events): """ _target_class_doc = "SomeEngine" - _dispatch_target = Connectable + _dispatch_target = ConnectionEventsTarget @classmethod def _listen(cls, event_key, retval=False): diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py index d1484718eb..11e55e4250 100644 --- a/lib/sqlalchemy/engine/interfaces.py +++ b/lib/sqlalchemy/engine/interfaces.py @@ -7,7 +7,6 @@ """Define core interfaces used by the engine system.""" -from .. import util from ..sql.compiler import Compiled # noqa from ..sql.compiler import TypeCompiler # noqa @@ -1320,9 +1319,7 @@ class ExecutionContext(object): 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. @@ -1527,48 +1524,43 @@ class ExecutionContext(object): 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() @@ -1576,13 +1568,8 @@ class Connectable(object): """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() diff --git a/lib/sqlalchemy/engine/mock.py b/lib/sqlalchemy/engine/mock.py index 803fe30a28..5da716b6b6 100644 --- a/lib/sqlalchemy/engine/mock.py +++ b/lib/sqlalchemy/engine/mock.py @@ -10,7 +10,6 @@ from operator import attrgetter from . import base from . import url as _url from .. import util -from ..sql import ddl class MockConnection(base.Connectable): @@ -22,32 +21,15 @@ 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 ): diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py index 3c2e682be6..48572c7fe0 100644 --- a/lib/sqlalchemy/engine/result.py +++ b/lib/sqlalchemy/engine/result.py @@ -25,8 +25,6 @@ from ..util import py2k if _baserow_usecext: from sqlalchemy.cresultproxy import tuplegetter - - _row_as_tuple = tuplegetter else: def tuplegetter(*indexes): @@ -37,16 +35,6 @@ else: 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.""" @@ -71,13 +59,6 @@ class ResultMetaData(object): 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" @@ -104,7 +85,7 @@ class ResultMetaData(object): 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): diff --git a/lib/sqlalchemy/engine/row.py b/lib/sqlalchemy/engine/row.py index dc11e35486..e268cfec90 100644 --- a/lib/sqlalchemy/engine/row.py +++ b/lib/sqlalchemy/engine/row.py @@ -40,19 +40,12 @@ except ImportError: 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 @@ -116,31 +109,12 @@ except ImportError: 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 @@ -190,26 +164,19 @@ class Row(BaseRow, collections_abc.Sequence): :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): @@ -217,10 +184,7 @@ class Row(BaseRow, collections_abc.Sequence): 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:: @@ -304,32 +268,6 @@ class Row(BaseRow, collections_abc.Sequence): 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 @@ -376,130 +314,6 @@ class Row(BaseRow, collections_abc.Sequence): 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 diff --git a/lib/sqlalchemy/sql/base.py b/lib/sqlalchemy/sql/base.py index aba80222a6..4bcb655d65 100644 --- a/lib/sqlalchemy/sql/base.py +++ b/lib/sqlalchemy/sql/base.py @@ -937,46 +937,6 @@ class Executable(roles.StatementRole, Generative): """ 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`", diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py index 0cd568fcc6..5c3fbb2b1f 100644 --- a/lib/sqlalchemy/sql/compiler.py +++ b/lib/sqlalchemy/sql/compiler.py @@ -3186,6 +3186,8 @@ class SQLCompiler(Compiled): # 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 ) diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py index 166ad98cd8..e45e22564d 100644 --- a/lib/sqlalchemy/sql/schema.py +++ b/lib/sqlalchemy/sql/schema.py @@ -2517,19 +2517,6 @@ class DefaultGenerator(Executable, SchemaItem): 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 ): diff --git a/lib/sqlalchemy/testing/assertions.py b/lib/sqlalchemy/testing/assertions.py index 6bf14aecde..c30fdf823e 100644 --- a/lib/sqlalchemy/testing/assertions.py +++ b/lib/sqlalchemy/testing/assertions.py @@ -204,11 +204,7 @@ def _expect_warnings( 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: diff --git a/lib/sqlalchemy/testing/profiling.py b/lib/sqlalchemy/testing/profiling.py index de4847f2f3..dd50402059 100644 --- a/lib/sqlalchemy/testing/profiling.py +++ b/lib/sqlalchemy/testing/profiling.py @@ -243,17 +243,12 @@ def function_call_count(variance=0.05, times=1, warmup=0): 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) diff --git a/lib/sqlalchemy/testing/suite/test_select.py b/lib/sqlalchemy/testing/suite/test_select.py index a3475f651b..63502b077f 100644 --- a/lib/sqlalchemy/testing/suite/test_select.py +++ b/lib/sqlalchemy/testing/suite/test_select.py @@ -206,8 +206,8 @@ class FetchLimitOffsetTest(fixtures.TablesTest): 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 diff --git a/regen_callcounts.tox.ini b/regen_callcounts.tox.ini index 80d88aa454..4f4fb6fe98 100644 --- a/regen_callcounts.tox.ini +++ b/regen_callcounts.tox.ini @@ -1,5 +1,5 @@ [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 diff --git a/test/aaa_profiling/test_memusage.py b/test/aaa_profiling/test_memusage.py index 624c12ea22..895cd9e0cd 100644 --- a/test/aaa_profiling/test_memusage.py +++ b/test/aaa_profiling/test_memusage.py @@ -1017,25 +1017,6 @@ class MemUsageWBackendTest(fixtures.MappedTest, EnsureZeroed): 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""" diff --git a/test/aaa_profiling/test_resultset.py b/test/aaa_profiling/test_resultset.py index ae0ea49921..83788ce464 100644 --- a/test/aaa_profiling/test_resultset.py +++ b/test/aaa_profiling/test_resultset.py @@ -7,7 +7,6 @@ from sqlalchemy import String 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_ @@ -112,15 +111,6 @@ class ResultSetTest(fixtures.TablesTest, AssertsExecutionResults): 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") @@ -176,7 +166,7 @@ class ResultSetTest(fixtures.TablesTest, AssertsExecutionResults): @profiling.function_call_count(variance=0.10) def go(): - c1 in row + c1 in row._mapping go() @@ -239,33 +229,6 @@ class RowTest(fixtures.TestBase): 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() @@ -294,7 +257,6 @@ class RowTest(fixtures.TestBase): 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): @@ -308,5 +270,4 @@ class RowTest(fixtures.TestBase): def __iter__(self): return iter(self.data) - self._test_getitem_value_refcounts_legacy(CustomSeq) self._test_getitem_value_refcounts_new(CustomSeq) diff --git a/test/engine/test_deprecations.py b/test/engine/test_deprecations.py index 39e2bf7625..3ab4a4e6c2 100644 --- a/test/engine/test_deprecations.py +++ b/test/engine/test_deprecations.py @@ -224,83 +224,21 @@ class ConnectionlessDeprecationTest(fixtures.TestBase): 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( @@ -349,40 +287,6 @@ class ConnectionlessDeprecationTest(fixtures.TestBase): 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): @@ -1157,8 +1061,9 @@ class DeprecatedEngineFeatureTest(fixtures.TablesTest): 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): @@ -1180,8 +1085,9 @@ class DeprecatedEngineFeatureTest(fixtures.TablesTest): ) 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,)) @@ -1737,7 +1643,8 @@ class EngineEventsTest(fixtures.TestBase): 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): @@ -1759,8 +1666,9 @@ class EngineEventsTest(fixtures.TestBase): 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): @@ -1774,45 +1682,6 @@ 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): diff --git a/test/engine/test_reconnect.py b/test/engine/test_reconnect.py index 51da845b39..20f6ec299a 100644 --- a/test/engine/test_reconnect.py +++ b/test/engine/test_reconnect.py @@ -18,7 +18,6 @@ from sqlalchemy.testing import assert_raises_message_context_ok 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 @@ -641,8 +640,8 @@ class MockReconnectTest(fixtures.TestBase): 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") @@ -654,31 +653,29 @@ class MockReconnectTest(fixtures.TestBase): 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", @@ -695,50 +692,16 @@ class MockReconnectTest(fixtures.TestBase): 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)) @@ -1120,10 +1083,7 @@ class RealReconnectTest(fixtures.TestBase): 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: diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py index fc2bc5b931..6a1a0cf165 100644 --- a/test/orm/test_deprecations.py +++ b/test/orm/test_deprecations.py @@ -3810,42 +3810,6 @@ class InstancesTest(QueryTest, AssertsCompiledSQL): 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, @@ -3878,47 +3842,6 @@ class InstancesTest(QueryTest, AssertsCompiledSQL): 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, diff --git a/test/profiles.txt b/test/profiles.txt index b99be23466..f345939908 100644 --- a/test/profiles.txt +++ b/test/profiles.txt @@ -13,736 +13,416 @@ # 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 diff --git a/test/requirements.py b/test/requirements.py index 687dadfd1a..02a9f065a5 100644 --- a/test/requirements.py +++ b/test/requirements.py @@ -1346,14 +1346,11 @@ class DefaultRequirements(SuiteRequirements): 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) @@ -1374,9 +1371,8 @@ class DefaultRequirements(SuiteRequirements): ): 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 @@ -1575,11 +1571,10 @@ class DefaultRequirements(SuiteRequirements): 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) @@ -1590,11 +1585,10 @@ class DefaultRequirements(SuiteRequirements): 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) diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py index 9b74ab1fa6..c70e474fe1 100644 --- a/test/sql/test_deprecations.py +++ b/test/sql/test_deprecations.py @@ -43,7 +43,6 @@ from sqlalchemy.sql import update 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 @@ -55,7 +54,6 @@ from sqlalchemy.testing import is_ 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 @@ -1199,182 +1197,6 @@ class KeyTargetingTest(fixtures.TablesTest): 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" @@ -1454,87 +1276,6 @@ class PKIncrementTest(fixtures.TablesTest): 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 @@ -1583,233 +1324,6 @@ class CursorResultTest(fixtures.TablesTest): ], ) - 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( @@ -1831,30 +1345,6 @@ class CursorResultTest(fixtures.TablesTest): 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" @@ -1914,126 +1404,6 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -2610,96 +1980,6 @@ class LegacyOperatorTest(AssertsCompiledSQL, fixtures.TestBase): 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: diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py index bf912bd255..843e6b4908 100644 --- a/test/sql/test_resultset.py +++ b/test/sql/test_resultset.py @@ -30,8 +30,6 @@ from sqlalchemy.engine import default 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 @@ -45,6 +43,7 @@ from sqlalchemy.testing import assert_raises_message 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_ @@ -97,6 +96,47 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -220,6 +260,9 @@ class CursorResultTest(fixtures.TablesTest): 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( @@ -230,8 +273,12 @@ class CursorResultTest(fixtures.TablesTest): 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(), @@ -271,12 +318,40 @@ class CursorResultTest(fixtures.TablesTest): 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): @@ -460,8 +535,21 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -485,6 +573,16 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -534,6 +632,16 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -651,12 +759,7 @@ class CursorResultTest(fixtures.TablesTest): 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. @@ -671,8 +774,6 @@ class CursorResultTest(fixtures.TablesTest): 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 [ @@ -689,20 +790,13 @@ class CursorResultTest(fixtures.TablesTest): 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): @@ -1095,29 +1189,17 @@ class CursorResultTest(fixtures.TablesTest): (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() @@ -1147,12 +1229,9 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -1160,13 +1239,10 @@ class CursorResultTest(fixtures.TablesTest): 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 @@ -1396,14 +1472,13 @@ class CursorResultTest(fixtures.TablesTest): ) 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)) @@ -1412,21 +1487,13 @@ class CursorResultTest(fixtures.TablesTest): 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, @@ -1442,45 +1509,6 @@ class CursorResultTest(fixtures.TablesTest): 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( @@ -1498,12 +1526,7 @@ class CursorResultTest(fixtures.TablesTest): ["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, @@ -1517,9 +1540,7 @@ class CursorResultTest(fixtures.TablesTest): ): 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): @@ -1914,8 +1935,6 @@ class KeyTargetingTest(fixtures.TablesTest): 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"]) @@ -1993,6 +2012,11 @@ class KeyTargetingTest(fixtures.TablesTest): 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 @@ -2002,6 +2026,11 @@ class KeyTargetingTest(fixtures.TablesTest): 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) @@ -2010,6 +2039,17 @@ class KeyTargetingTest(fixtures.TablesTest): 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 @@ -2026,6 +2066,14 @@ class KeyTargetingTest(fixtures.TablesTest): 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] @@ -2037,6 +2085,14 @@ class KeyTargetingTest(fixtures.TablesTest): 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 = ( @@ -2165,14 +2221,14 @@ class KeyTargetingTest(fixtures.TablesTest): 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() @@ -2344,6 +2400,20 @@ class PositionalTextTest(fixtures.TablesTest): 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( @@ -2369,6 +2439,13 @@ class PositionalTextTest(fixtures.TablesTest): 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 -- 2.47.2