diff options
33 files changed, 967 insertions, 934 deletions
diff --git a/doc/build/changelog/unreleased_13/5132.rst b/doc/build/changelog/unreleased_13/5132.rst new file mode 100644 index 000000000..d4e68f277 --- /dev/null +++ b/doc/build/changelog/unreleased_13/5132.rst @@ -0,0 +1,10 @@ +.. change:: + :tags: bug, mssql + :tickets: 5132 + + Fixed issue where the :class:`.mssql.DATETIMEOFFSET` type would not + accommodate for the ``None`` value, introduced as part of the series of + fixes for this type first introduced in :ticket:`4983`, :ticket:`5045`. + Additionally, added support for passing a backend-specific date formatted + string through this type, as is typically allowed for date/time types on + most other DBAPIs. diff --git a/doc/build/changelog/unreleased_13/5138.rst b/doc/build/changelog/unreleased_13/5138.rst new file mode 100644 index 000000000..e0a04b1b0 --- /dev/null +++ b/doc/build/changelog/unreleased_13/5138.rst @@ -0,0 +1,9 @@ +.. change:: + :tags: bug, installation + :tickets: 5138 + + Vendored the ``inspect.formatannotation`` function inside of + ``sqlalchemy.util.compat``, which is needed for the vendored version of + ``inspect.formatargspec``. The function is not documented in cPython and + is not guaranteed to be available in future Python versions. + diff --git a/doc/build/changelog/unreleased_13/5149.rst b/doc/build/changelog/unreleased_13/5149.rst new file mode 100644 index 000000000..9550a7aa0 --- /dev/null +++ b/doc/build/changelog/unreleased_13/5149.rst @@ -0,0 +1,11 @@ +.. change:: + :tags: bug, orm + :tickets: 5149 + + Setting a relationship to viewonly=True which is also the target of a + back_populates or backref configuration will now emit a warning and + eventually be disallowed. back_populates refers specifically to mutation + of an attribute or collection, which is disallowed when the attribute is + subject to viewonly=True. The viewonly attribute is not subject to + persistence behaviors which means it will not reflect correct results + when it is locally mutated. diff --git a/doc/build/core/connections.rst b/doc/build/core/connections.rst index c1b2ff398..e205a37b5 100644 --- a/doc/build/core/connections.rst +++ b/doc/build/core/connections.rst @@ -655,7 +655,6 @@ Connection / Engine API .. autoclass:: ResultProxy :members: - :private-members: _soft_close .. autoclass:: Row :members: diff --git a/doc/build/core/tutorial.rst b/doc/build/core/tutorial.rst index 77bf2ace0..9b58222f2 100644 --- a/doc/build/core/tutorial.rst +++ b/doc/build/core/tutorial.rst @@ -395,8 +395,10 @@ generated a FROM clause for us. The result returned is again a :class:`~sqlalchemy.engine.ResultProxy` object, which acts much like a DBAPI cursor, including methods such as :func:`~sqlalchemy.engine.ResultProxy.fetchone` and -:func:`~sqlalchemy.engine.ResultProxy.fetchall`. The easiest way to get -rows from it is to just iterate: +:func:`~sqlalchemy.engine.ResultProxy.fetchall`. These methods return +row objects, which are provided via the :class:`.Row` class. The +result object can be iterated directly in order to provide an iterator +of :class:`.Row` objects: .. sourcecode:: pycon+sql @@ -405,9 +407,11 @@ rows from it is to just iterate: (1, u'jack', u'Jack Jones') (2, u'wendy', u'Wendy Williams') -Above, we see that printing each row produces a simple tuple-like result. We -have more options at accessing the data in each row. One very common way is -through dictionary access, using the string names of columns: +Above, we see that printing each :class:`.Row` produces a simple +tuple-like result. The :class:`.Row` behaves like a hybrid between +a Python mapping and tuple, with several methods of retrieving the data +in each column. One common way is +as a Python mapping of strings, using the string names of columns: .. sourcecode:: pycon+sql @@ -420,7 +424,7 @@ through dictionary access, using the string names of columns: >>> print("name:", row['name'], "; fullname:", row['fullname']) name: jack ; fullname: Jack Jones -Integer indexes work as well: +Another way is as a Python sequence, using integer indexes: .. sourcecode:: pycon+sql @@ -428,8 +432,10 @@ Integer indexes work as well: >>> print("name:", row[1], "; fullname:", row[2]) name: wendy ; fullname: Wendy Williams -But another way, whose usefulness will become apparent later on, is to use the -:class:`~sqlalchemy.schema.Column` objects directly as keys: +A more specialized method of column access is to use the SQL construct that +directly corresponds to a particular column as the mapping key; in this +example, it means we would use the :class:`.Column` objects selected in our +SELECT directly as keys: .. sourcecode:: pycon+sql @@ -441,17 +447,19 @@ But another way, whose usefulness will become apparent later on, is to use the {stop}name: jack ; fullname: Jack Jones name: wendy ; fullname: Wendy Williams -Result sets which have pending rows remaining should be explicitly closed -before discarding. While the cursor and connection resources referenced by the -:class:`~sqlalchemy.engine.ResultProxy` will be respectively closed and -returned to the connection pool when the object is garbage collected, it's -better to make it explicit as some database APIs are very picky about such -things: +The :class:`.ResultProxy` object features "auto-close" behavior that closes the +underlying DBAPI ``cursor`` object when all pending result rows have been +fetched. If a :class:`.ResultProxy` is to be discarded before such an +autoclose has occurred, it can be explicitly closed using the +:meth:`.ResultProxy.close` method: .. sourcecode:: pycon+sql >>> result.close() +Selecting Specific Columns +=========================== + If we'd like to more carefully control the columns which are placed in the COLUMNS clause of the select, we reference individual :class:`~sqlalchemy.schema.Column` objects from our diff --git a/doc/build/dialects/mysql.rst b/doc/build/dialects/mysql.rst index bfd345bc0..760a0a91d 100644 --- a/doc/build/dialects/mysql.rst +++ b/doc/build/dialects/mysql.rst @@ -159,9 +159,9 @@ construction arguments, are as follows: MySQL DML Constructs ------------------------- -.. autofunction:: sqlalchemy.dialects.mysql.dml.insert +.. autofunction:: sqlalchemy.dialects.mysql.insert -.. autoclass:: sqlalchemy.dialects.mysql.dml.Insert +.. autoclass:: sqlalchemy.dialects.mysql.Insert :members: diff --git a/doc/build/dialects/postgresql.rst b/doc/build/dialects/postgresql.rst index e03fba8d3..35ed285eb 100644 --- a/doc/build/dialects/postgresql.rst +++ b/doc/build/dialects/postgresql.rst @@ -181,9 +181,9 @@ For example:: PostgreSQL DML Constructs ------------------------- -.. autofunction:: sqlalchemy.dialects.postgresql.dml.insert +.. autofunction:: sqlalchemy.dialects.postgresql.insert -.. autoclass:: sqlalchemy.dialects.postgresql.dml.Insert +.. autoclass:: sqlalchemy.dialects.postgresql.Insert :members: psycopg2 diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py index 1c47902ab..1b1bd8c5c 100644 --- a/lib/sqlalchemy/dialects/mssql/base.py +++ b/lib/sqlalchemy/dialects/mssql/base.py @@ -245,9 +245,16 @@ CREATE TABLE statement for this column will yield:: LIMIT/OFFSET Support -------------------- -MSSQL has no support for the LIMIT or OFFSET keywords. LIMIT is -supported directly through the ``TOP`` Transact SQL keyword. A statement -such as:: +MSSQL has added support for LIMIT / OFFSET as of SQL Server 2012, via the +"OFFSET n ROWS" and "FETCH NEXT n ROWS" clauses. SQLAlchemy supports these +syntaxes automatically if SQL Server 2012 or greater is detected. + +.. versionchanged:: 1.4 support added for SQL Server "OFFSET n ROWS" and + "FETCH NEXT n ROWS" syntax. + +For statements that specify only LIMIT and no OFFSET, all versions of SQL +Server support the TOP keyword. This syntax is used for all SQL Server +versions when no OFFSET clause is present. A statement such as:: select([some_table]).limit(5) @@ -255,8 +262,9 @@ will render similarly to:: SELECT TOP 5 col1, col2.. FROM table -LIMIT with OFFSET support is implemented using the using the ``ROW_NUMBER()`` -window function. A statement such as:: +For versions of SQL Server prior to SQL Server 2012, a statement that uses +LIMIT and OFFSET, or just OFFSET alone, will be rendered using the +``ROW_NUMBER()`` window function. A statement such as:: select([some_table]).order_by(some_table.c.col3).limit(5).offset(10) @@ -267,8 +275,9 @@ will render similarly to:: mssql_rn FROM table WHERE t.x = :x_1) AS anon_1 WHERE mssql_rn > :param_1 AND mssql_rn <= :param_2 + :param_1 -Note that when using LIMIT and OFFSET together, the statement must have -an ORDER BY as well. +Note that when using LIMIT and/or OFFSET, whether using the older +or newer SQL Server syntaxes, the statement must have an ORDER BY as well, +else a :class:`.CompileError` is raised. .. _mssql_isolation_level: @@ -1220,7 +1229,7 @@ class TryCast(sql.elements.Cast): super(TryCast, self).__init__(*arg, **kw) -try_cast = public_factory(TryCast, ".mssql.try_cast") +try_cast = public_factory(TryCast, ".dialects.mssql.try_cast") # old names. MSDateTime = _MSDateTime @@ -1641,10 +1650,7 @@ class MSSQLCompiler(compiler.SQLCompiler): """ if self.dialect._supports_offset_fetch and ( - ( - not select._simple_int_limit - and select._limit_clause is not None - ) + (not select._simple_int_limit and select._limit_clause is not None) or ( select._offset_clause is not None and not select._simple_int_offset @@ -1664,7 +1670,7 @@ class MSSQLCompiler(compiler.SQLCompiler): if select._offset_clause is not None: offset_str = self.process(select._offset_clause, **kw) else: - offset_str = '0' + offset_str = "0" text += "\n OFFSET %s ROWS" % offset_str if select._limit_clause is not None: @@ -1687,14 +1693,21 @@ class MSSQLCompiler(compiler.SQLCompiler): MSSQL 2012 and above are excluded """ - if not self.dialect._supports_offset_fetch and ( - (not select._simple_int_limit and select._limit_clause is not None) - or ( - select._offset_clause is not None - and not select._simple_int_offset - or select._offset + if ( + not self.dialect._supports_offset_fetch + and ( + ( + not select._simple_int_limit + and select._limit_clause is not None + ) + or ( + select._offset_clause is not None + and not select._simple_int_offset + or select._offset + ) ) - ) and not getattr(select, "_mssql_visit", None): + and not getattr(select, "_mssql_visit", None) + ): # to use ROW_NUMBER(), an ORDER BY is required. if not select._order_by_clause.clauses: @@ -1880,7 +1893,11 @@ class MSSQLCompiler(compiler.SQLCompiler): def order_by_clause(self, select, **kw): # MSSQL only allows ORDER BY in subqueries if there is a LIMIT - if self.is_subquery() and not select._limit: + if ( + self.is_subquery() + and not select._limit + and (not select._offset or not self.dialect._supports_offset_fetch) + ): # avoid processing the order by clause if we won't end up # using it, because we don't want all the bind params tacked # onto the positional list if that is what the dbapi requires @@ -2476,7 +2493,8 @@ class MSDialect(default.DefaultDialect): ) self._supports_offset_fetch = ( - self.server_version_info and self.server_version_info[0] >= 11) + self.server_version_info and self.server_version_info[0] >= 11 + ) def _get_default_schema_name(self, connection): if self.server_version_info < MS_2005_VERSION: diff --git a/lib/sqlalchemy/dialects/mssql/pyodbc.py b/lib/sqlalchemy/dialects/mssql/pyodbc.py index 879fe9a2a..4ba3a0dfa 100644 --- a/lib/sqlalchemy/dialects/mssql/pyodbc.py +++ b/lib/sqlalchemy/dialects/mssql/pyodbc.py @@ -234,10 +234,21 @@ class _ms_binary_pyodbc(object): class _ODBCDateTimeOffset(DATETIMEOFFSET): def bind_processor(self, dialect): def process(value): - """Convert to string format required by T-SQL.""" - dto_string = value.strftime("%Y-%m-%d %H:%M:%S.%f %z") - # offset needs a colon, e.g., -0700 -> -07:00 - return dto_string[:30] + ":" + dto_string[30:] + if value is None: + return None + elif isinstance(value, util.string_types): + # if a string was passed directly, allow it through + return value + else: + # Convert to string format required by T-SQL + dto_string = value.strftime("%Y-%m-%d %H:%M:%S.%f %z") + # offset needs a colon, e.g., -0700 -> -07:00 + # "UTC offset in the form (+-)HHMM[SS[.ffffff]]" + # backend currently rejects seconds / fractional seconds + dto_string = re.sub( + r"([\+\-]\d{2})([\d\.]+)$", r"\1:\2", dto_string + ) + return dto_string return process diff --git a/lib/sqlalchemy/dialects/mysql/base.py b/lib/sqlalchemy/dialects/mysql/base.py index 6e84c9da1..e0bf16793 100644 --- a/lib/sqlalchemy/dialects/mysql/base.py +++ b/lib/sqlalchemy/dialects/mysql/base.py @@ -352,8 +352,8 @@ will be performed. The statement allows for separate specification of the values to INSERT versus the values for UPDATE. SQLAlchemy provides ``ON DUPLICATE KEY UPDATE`` support via the MySQL-specific -:func:`.mysql.dml.insert()` function, which provides -the generative method :meth:`~.mysql.dml.Insert.on_duplicate_key_update`:: +:func:`.mysql.insert()` function, which provides +the generative method :meth:`~.mysql.Insert.on_duplicate_key_update`:: from sqlalchemy.dialects.mysql import insert @@ -377,7 +377,7 @@ an error or to skip performing an UPDATE. existing row, using any combination of new values as well as values from the proposed insertion. These values are normally specified using keyword arguments passed to the -:meth:`~.mysql.dml.Insert.on_duplicate_key_update` +:meth:`~.mysql.Insert.on_duplicate_key_update` given column key values (usually the name of the column, unless it specifies :paramref:`.Column.key`) as keys and literal or SQL expressions as values:: @@ -421,8 +421,8 @@ this context is unambiguous:: In order to refer to the proposed insertion row, the special alias -:attr:`~.mysql.dml.Insert.inserted` is available as an attribute on -the :class:`.mysql.dml.Insert` object; this object is a +:attr:`~.mysql.Insert.inserted` is available as an attribute on +the :class:`.mysql.Insert` object; this object is a :class:`.ColumnCollection` which contains all columns of the target table:: diff --git a/lib/sqlalchemy/dialects/mysql/dml.py b/lib/sqlalchemy/dialects/mysql/dml.py index b43b364fa..531b31bc3 100644 --- a/lib/sqlalchemy/dialects/mysql/dml.py +++ b/lib/sqlalchemy/dialects/mysql/dml.py @@ -15,6 +15,9 @@ class Insert(StandardInsert): Adds methods for MySQL-specific syntaxes such as ON DUPLICATE KEY UPDATE. + The :class:`~.mysql.Insert` object is created using the + :func:`sqlalchemy.dialects.mysql.insert` function. + .. versionadded:: 1.2 """ @@ -105,7 +108,9 @@ class Insert(StandardInsert): self._post_values_clause = OnDuplicateClause(inserted_alias, values) -insert = public_factory(Insert, ".dialects.mysql.insert") +insert = public_factory( + Insert, ".dialects.mysql.insert", ".dialects.mysql.Insert" +) class OnDuplicateClause(ClauseElement): diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py index 82c619c85..ceefc20b0 100644 --- a/lib/sqlalchemy/dialects/postgresql/base.py +++ b/lib/sqlalchemy/dialects/postgresql/base.py @@ -304,9 +304,9 @@ or they may be *inferred* by stating the columns and conditions that comprise the indexes. SQLAlchemy provides ``ON CONFLICT`` support via the PostgreSQL-specific -:func:`.postgresql.dml.insert()` function, which provides -the generative methods :meth:`~.postgresql.dml.Insert.on_conflict_do_update` -and :meth:`~.postgresql.dml.Insert.on_conflict_do_nothing`:: +:func:`.postgresql.insert()` function, which provides +the generative methods :meth:`~.postgresql.Insert.on_conflict_do_update` +and :meth:`~.postgresql.Insert.on_conflict_do_nothing`:: from sqlalchemy.dialects.postgresql import insert @@ -415,8 +415,8 @@ for UPDATE:: :paramref:`.Insert.on_conflict_do_update.set_` dictionary. In order to refer to the proposed insertion row, the special alias -:attr:`~.postgresql.dml.Insert.excluded` is available as an attribute on -the :class:`.postgresql.dml.Insert` object; this object is a +:attr:`~.postgresql.Insert.excluded` is available as an attribute on +the :class:`.postgresql.Insert` object; this object is a :class:`.ColumnCollection` which alias contains all columns of the target table:: @@ -452,7 +452,7 @@ parameter, which will limit those rows which receive an UPDATE:: ``ON CONFLICT`` may also be used to skip inserting a row entirely if any conflict with a unique or exclusion constraint occurs; below this is illustrated using the -:meth:`~.postgresql.dml.Insert.on_conflict_do_nothing` method:: +:meth:`~.postgresql.Insert.on_conflict_do_nothing` method:: from sqlalchemy.dialects.postgresql import insert diff --git a/lib/sqlalchemy/dialects/postgresql/dml.py b/lib/sqlalchemy/dialects/postgresql/dml.py index ec40ae87e..626f81018 100644 --- a/lib/sqlalchemy/dialects/postgresql/dml.py +++ b/lib/sqlalchemy/dialects/postgresql/dml.py @@ -23,6 +23,9 @@ class Insert(StandardInsert): Adds methods for PG-specific syntaxes such as ON CONFLICT. + The :class:`.postgresql.Insert` object is created using the + :func:`sqlalchemy.dialects.postgresql.insert` function. + .. versionadded:: 1.1 """ @@ -139,7 +142,9 @@ class Insert(StandardInsert): ) -insert = public_factory(Insert, ".dialects.postgresql.insert") +insert = public_factory( + Insert, ".dialects.postgresql.insert", ".dialects.postgresql.Insert" +) class OnConflictClause(ClauseElement): diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py index c2f976aa0..13738cb46 100644 --- a/lib/sqlalchemy/engine/result.py +++ b/lib/sqlalchemy/engine/result.py @@ -129,9 +129,12 @@ except ImportError: class Row(BaseRow, collections_abc.Sequence): """Represent a single result row. + The :class:`.Row` object is retrieved from a database result, from the + :class:`.ResultProxy` object using methods like + :meth:`.ResultProxy.fetchall`. + The :class:`.Row` object seeks to act mostly like a Python named - tuple, but also provides for mapping-oriented access via the - :attr:`.Row._mapping` attribute. + tuple, but also provides some Python dictionary behaviors at the same time. .. seealso:: @@ -189,7 +192,22 @@ class Row(BaseRow, collections_abc.Sequence): return repr(sql_util._repr_row(self)) def has_key(self, key): - """Return True if this Row contains the given key.""" + """Return True if this :class:`.Row` contains the given key. + + Through the SQLAlchemy 1.x series, the ``__contains__()`` method + of :class:`.Row` 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. + + """ return self._parent._has_key(key) @@ -197,23 +215,52 @@ class Row(BaseRow, collections_abc.Sequence): return self._get_by_key_impl(key) def items(self): - """Return a list of tuples, each tuple containing a key/value pair.""" - # TODO: no coverage here + """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()] def keys(self): - """Return the list of keys as strings represented by this Row.""" + """Return the list of keys as strings represented by this + :class:`.Row`. + + This method is analogous to the Python dictionary ``.keys()`` method, + except that it returns a list, not an iterator. + + """ return [k for k in self._parent.keys if k is not None] 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) 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) def values(self): - """Return the values represented by this Row as a list.""" + """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() @@ -827,23 +874,16 @@ class ResultMetaData(object): class ResultProxy(object): - """Wraps a DB-API cursor object to provide easier access to row columns. - - Individual columns may be accessed by their integer position, - case-insensitive column name, or by ``schema.Column`` - object. e.g.:: - - row = fetchone() - - col1 = row[0] # access via integer position + """A facade around a DBAPI cursor object. - col2 = row['col2'] # access via name + Returns database rows via the :class:`.Row` class, which provides + additional API features and behaviors on top of the raw data returned + by the DBAPI. - col3 = row[mytable.c.mycol] # access via Column object. + .. seealso:: - ``ResultProxy`` also handles post-processing of result column - data using ``TypeEngine`` objects, which are referenced from - the originating SQL statement that produced this result set. + :ref:`coretutorial_selecting` - introductory material for accessing + :class:`.ResultProxy` and :class:`.Row` objects. """ @@ -912,7 +952,9 @@ class ResultProxy(object): ) def keys(self): - """Return the current set of string keys for rows.""" + """Return the list of string keys that would represented by each + :class:`.Row`.""" + if self._metadata: return self._metadata.keys else: @@ -1085,8 +1127,6 @@ class ResultProxy(object): :ref:`connections_toplevel` - :meth:`.ResultProxy._soft_close` - """ if not self.closed: @@ -1104,7 +1144,10 @@ class ResultProxy(object): yield row def __next__(self): - """Implement the next() protocol. + """Implement the Python next() protocol. + + This method, mirrored as both ``.next()`` and ``.__next__()``, is part + of Python's API for producing iterator-like behavior. .. versionadded:: 1.2 @@ -1358,9 +1401,7 @@ class ResultProxy(object): an empty list. After the :meth:`.ResultProxy.close` method is called, the method will raise :class:`.ResourceClosedError`. - .. versionchanged:: 1.0.0 - Added "soft close" behavior which - allows the result to be used in an "exhausted" state prior to - calling the :meth:`.ResultProxy.close` method. + :return: a list of :class:`.Row` objects """ @@ -1386,9 +1427,7 @@ class ResultProxy(object): an empty list. After the :meth:`.ResultProxy.close` method is called, the method will raise :class:`.ResourceClosedError`. - .. versionchanged:: 1.0.0 - Added "soft close" behavior which - allows the result to be used in an "exhausted" state prior to - calling the :meth:`.ResultProxy.close` method. + :return: a list of :class:`.Row` objects """ @@ -1414,9 +1453,7 @@ class ResultProxy(object): After the :meth:`.ResultProxy.close` method is called, the method will raise :class:`.ResourceClosedError`. - .. versionchanged:: 1.0.0 - Added "soft close" behavior which - allows the result to be used in an "exhausted" state prior to - calling the :meth:`.ResultProxy.close` method. + :return: a :class:`.Row` object, or None if no rows remain """ try: @@ -1434,11 +1471,11 @@ class ResultProxy(object): def first(self): """Fetch the first row and then close the result set unconditionally. - Returns None if no row is present. - After calling this method, the object is fully closed, e.g. the :meth:`.ResultProxy.close` method will have been called. + :return: a :class:`.Row` object, or None if no rows remain + """ if self._metadata is None: return self._non_result(None) @@ -1461,11 +1498,11 @@ class ResultProxy(object): def scalar(self): """Fetch the first column of the first row, and close the result set. - Returns None if no row is present. - After calling this method, the object is fully closed, e.g. the :meth:`.ResultProxy.close` method will have been called. + :return: a Python scalar value , or None if no rows remain + """ row = self.first() if row is not None: diff --git a/lib/sqlalchemy/orm/relationships.py b/lib/sqlalchemy/orm/relationships.py index d745500c1..5573f7c9a 100644 --- a/lib/sqlalchemy/orm/relationships.py +++ b/lib/sqlalchemy/orm/relationships.py @@ -827,6 +827,19 @@ class RelationshipProperty(StrategizedProperty): the full set of related objects, to prevent modifications of the collection from resulting in persistence operations. + .. warning:: The viewonly=True relationship should not be mutated + in Python; that means, elements should not be added or removed + from collections nor should a many-to-one or one-to-one attribute + be altered in Python. The viewonly=True relationship should only + be accessed via read. Towards this behavior, it is also not + appropriate for the viewonly=True relationship to have any kind + of persistence cascade settings, nor should it be the target of + either :paramref:`.relationship.backref` or + :paramref:`.relationship.back_populates`, as backrefs imply + in-Python mutation of the attribute. SQLAlchemy may emit + warnings for some or all of these conditions as of the 1.3 and + 1.4 series of SQLAlchemy and will eventually be disallowed. + :param omit_join: Allows manual control over the "selectin" automatic join optimization. Set to ``False`` to disable the "omit join" feature @@ -1841,6 +1854,14 @@ class RelationshipProperty(StrategizedProperty): def _add_reverse_property(self, key): other = self.mapper.get_property(key, _configure_mappers=False) + if other.viewonly: + util.warn_limited( + "Setting backref / back_populates on relationship %s to refer " + "to viewonly relationship %s will be deprecated in SQLAlchemy " + "1.4, and will be disallowed in a future release. " + "viewonly relationships should not be mutated", + (self, other), + ) self._reverse_property.add(other) other._reverse_property.add(self) diff --git a/lib/sqlalchemy/sql/expression.py b/lib/sqlalchemy/sql/expression.py index 9cd6a179a..7ea0e2ad3 100644 --- a/lib/sqlalchemy/sql/expression.py +++ b/lib/sqlalchemy/sql/expression.py @@ -164,62 +164,66 @@ from ..util.langhelpers import public_factory # noqa # the functions to be available in the sqlalchemy.sql.* namespace and # to be auto-cross-documenting from the function to the class itself. -all_ = public_factory(CollectionAggregate._create_all, ".expression.all_") -any_ = public_factory(CollectionAggregate._create_any, ".expression.any_") -and_ = public_factory(BooleanClauseList.and_, ".expression.and_") -alias = public_factory(Alias._factory, ".expression.alias") -tablesample = public_factory(TableSample._factory, ".expression.tablesample") -lateral = public_factory(Lateral._factory, ".expression.lateral") -or_ = public_factory(BooleanClauseList.or_, ".expression.or_") -bindparam = public_factory(BindParameter, ".expression.bindparam") -select = public_factory(Select, ".expression.select") -text = public_factory(TextClause._create_text, ".expression.text") -table = public_factory(TableClause, ".expression.table") -column = public_factory(ColumnClause, ".expression.column") -over = public_factory(Over, ".expression.over") -within_group = public_factory(WithinGroup, ".expression.within_group") -label = public_factory(Label, ".expression.label") -case = public_factory(Case, ".expression.case") -cast = public_factory(Cast, ".expression.cast") -cte = public_factory(CTE._factory, ".expression.cte") -extract = public_factory(Extract, ".exp # noqaression.extract") -tuple_ = public_factory(Tuple, ".expression.tuple_") -except_ = public_factory(CompoundSelect._create_except, ".expression.except_") +all_ = public_factory(CollectionAggregate._create_all, ".sql.expression.all_") +any_ = public_factory(CollectionAggregate._create_any, ".sql.expression.any_") +and_ = public_factory(BooleanClauseList.and_, ".sql.expression.and_") +alias = public_factory(Alias._factory, ".sql.expression.alias") +tablesample = public_factory( + TableSample._factory, ".sql.expression.tablesample" +) +lateral = public_factory(Lateral._factory, ".sql.expression.lateral") +or_ = public_factory(BooleanClauseList.or_, ".sql.expression.or_") +bindparam = public_factory(BindParameter, ".sql.expression.bindparam") +select = public_factory(Select, ".sql.expression.select") +text = public_factory(TextClause._create_text, ".sql.expression.text") +table = public_factory(TableClause, ".sql.expression.table") +column = public_factory(ColumnClause, ".sql.expression.column") +over = public_factory(Over, ".sql.expression.over") +within_group = public_factory(WithinGroup, ".sql.expression.within_group") +label = public_factory(Label, ".sql.expression.label") +case = public_factory(Case, ".sql.expression.case") +cast = public_factory(Cast, ".sql.expression.cast") +cte = public_factory(CTE._factory, ".sql.expression.cte") +extract = public_factory(Extract, ".sql.expression.extract") +tuple_ = public_factory(Tuple, ".sql.expression.tuple_") +except_ = public_factory( + CompoundSelect._create_except, ".sql.expression.except_" +) except_all = public_factory( - CompoundSelect._create_except_all, ".expression.except_all" + CompoundSelect._create_except_all, ".sql.expression.except_all" ) intersect = public_factory( - CompoundSelect._create_intersect, ".expression.intersect" + CompoundSelect._create_intersect, ".sql.expression.intersect" ) intersect_all = public_factory( - CompoundSelect._create_intersect_all, ".expression.intersect_all" + CompoundSelect._create_intersect_all, ".sql.expression.intersect_all" ) -union = public_factory(CompoundSelect._create_union, ".expression.union") +union = public_factory(CompoundSelect._create_union, ".sql.expression.union") union_all = public_factory( - CompoundSelect._create_union_all, ".expression.union_all" + CompoundSelect._create_union_all, ".sql.expression.union_all" ) -exists = public_factory(Exists, ".expression.exists") +exists = public_factory(Exists, ".sql.expression.exists") nullsfirst = public_factory( - UnaryExpression._create_nullsfirst, ".expression.nullsfirst" + UnaryExpression._create_nullsfirst, ".sql.expression.nullsfirst" ) nullslast = public_factory( - UnaryExpression._create_nullslast, ".expression.nullslast" + UnaryExpression._create_nullslast, ".sql.expression.nullslast" ) -asc = public_factory(UnaryExpression._create_asc, ".expression.asc") -desc = public_factory(UnaryExpression._create_desc, ".expression.desc") +asc = public_factory(UnaryExpression._create_asc, ".sql.expression.asc") +desc = public_factory(UnaryExpression._create_desc, ".sql.expression.desc") distinct = public_factory( - UnaryExpression._create_distinct, ".expression.distinct" + UnaryExpression._create_distinct, ".sql.expression.distinct" ) -type_coerce = public_factory(TypeCoerce, ".expression.type_coerce") -true = public_factory(True_._instance, ".expression.true") -false = public_factory(False_._instance, ".expression.false") -null = public_factory(Null._instance, ".expression.null") -join = public_factory(Join._create_join, ".expression.join") -outerjoin = public_factory(Join._create_outerjoin, ".expression.outerjoin") -insert = public_factory(Insert, ".expression.insert") -update = public_factory(Update, ".expression.update") -delete = public_factory(Delete, ".expression.delete") -funcfilter = public_factory(FunctionFilter, ".expression.funcfilter") +type_coerce = public_factory(TypeCoerce, ".sql.expression.type_coerce") +true = public_factory(True_._instance, ".sql.expression.true") +false = public_factory(False_._instance, ".sql.expression.false") +null = public_factory(Null._instance, ".sql.expression.null") +join = public_factory(Join._create_join, ".sql.expression.join") +outerjoin = public_factory(Join._create_outerjoin, ".sql.expression.outerjoin") +insert = public_factory(Insert, ".sql.expression.insert") +update = public_factory(Update, ".sql.expression.update") +delete = public_factory(Delete, ".sql.expression.delete") +funcfilter = public_factory(FunctionFilter, ".sql.expression.funcfilter") # internal functions still being called from tests and the ORM, diff --git a/lib/sqlalchemy/testing/exclusions.py b/lib/sqlalchemy/testing/exclusions.py index b2828b107..0c05bf9e9 100644 --- a/lib/sqlalchemy/testing/exclusions.py +++ b/lib/sqlalchemy/testing/exclusions.py @@ -35,20 +35,10 @@ class compound(object): self.fails = set() self.skips = set() self.tags = set() - self.combinations = {} def __add__(self, other): return self.add(other) - def with_combination(self, **kw): - copy = compound() - copy.fails.update(self.fails) - copy.skips.update(self.skips) - copy.tags.update(self.tags) - copy.combinations.update((f, kw) for f in copy.fails) - copy.combinations.update((s, kw) for s in copy.skips) - return copy - def add(self, *others): copy = compound() copy.fails.update(self.fails) @@ -95,7 +85,6 @@ class compound(object): self.skips.update(other.skips) self.fails.update(other.fails) self.tags.update(other.tags) - self.combinations.update(other.combinations) def __call__(self, fn): if hasattr(fn, "_sa_exclusion_extend"): @@ -118,29 +107,13 @@ class compound(object): try: yield except Exception as ex: - all_fails._expect_failure(config._current, ex, None) + all_fails._expect_failure(config._current, ex) else: - all_fails._expect_success(config._current, None) - - def _check_combinations(self, combination, predicate): - if predicate in self.combinations: - for k, v in combination: - if ( - k in self.combinations[predicate] - and self.combinations[predicate][k] != v - ): - return False - return True + all_fails._expect_success(config._current) def _do(self, cfg, fn, *args, **kw): - if len(args) > 1: - insp = inspect_getfullargspec(fn) - combination = list(zip(insp.args[1:], args[1:])) - else: - combination = None - for skip in self.skips: - if self._check_combinations(combination, skip) and skip(cfg): + if skip(cfg): msg = "'%s' : %s" % ( config.get_current_test_name(), skip._as_string(cfg), @@ -150,14 +123,14 @@ class compound(object): try: return_value = fn(*args, **kw) except Exception as ex: - self._expect_failure(cfg, ex, combination, name=fn.__name__) + self._expect_failure(cfg, ex, name=fn.__name__) else: - self._expect_success(cfg, combination, name=fn.__name__) + self._expect_success(cfg, name=fn.__name__) return return_value - def _expect_failure(self, config, ex, combination, name="block"): + def _expect_failure(self, config, ex, name="block"): for fail in self.fails: - if self._check_combinations(combination, fail) and fail(config): + if fail(config): if util.py2k: str_ex = unicode(ex).encode( # noqa: F821 "utf-8", errors="ignore" @@ -174,12 +147,12 @@ class compound(object): else: util.raise_from_cause(ex) - def _expect_success(self, config, combination, name="block"): + def _expect_success(self, config, name="block"): if not self.fails: return for fail in self.fails: - if self._check_combinations(combination, fail) and fail(config): + if fail(config): raise AssertionError( "Unexpected success for '%s' (%s)" % ( diff --git a/lib/sqlalchemy/testing/plugin/pytestplugin.py b/lib/sqlalchemy/testing/plugin/pytestplugin.py index 3e0630890..c39f9f32e 100644 --- a/lib/sqlalchemy/testing/plugin/pytestplugin.py +++ b/lib/sqlalchemy/testing/plugin/pytestplugin.py @@ -7,6 +7,7 @@ except ImportError: import argparse import collections +from functools import update_wrapper import inspect import itertools import operator @@ -16,6 +17,13 @@ import sys import pytest +try: + import typing +except ImportError: + pass +else: + if typing.TYPE_CHECKING: + from typing import Sequence try: import xdist # noqa @@ -295,6 +303,49 @@ def getargspec(fn): return inspect.getargspec(fn) +def _pytest_fn_decorator(target): + """Port of langhelpers.decorator with pytest-specific tricks.""" + + from sqlalchemy.util.langhelpers import format_argspec_plus + from sqlalchemy.util.compat import inspect_getfullargspec + + def _exec_code_in_env(code, env, fn_name): + exec(code, env) + return env[fn_name] + + def decorate(fn, add_positional_parameters=()): + + spec = inspect_getfullargspec(fn) + if add_positional_parameters: + spec.args.extend(add_positional_parameters) + + metadata = dict(target="target", fn="fn", name=fn.__name__) + metadata.update(format_argspec_plus(spec, grouped=False)) + code = ( + """\ +def %(name)s(%(args)s): + return %(target)s(%(fn)s, %(apply_kw)s) +""" + % metadata + ) + decorated = _exec_code_in_env( + code, {"target": target, "fn": fn}, fn.__name__ + ) + if not add_positional_parameters: + decorated.__defaults__ = getattr(fn, "im_func", fn).__defaults__ + decorated.__wrapped__ = fn + return update_wrapper(decorated, fn) + else: + # this is the pytest hacky part. don't do a full update wrapper + # because pytest is really being sneaky about finding the args + # for the wrapped function + decorated.__module__ = fn.__module__ + decorated.__name__ = fn.__name__ + return decorated + + return decorate + + class PytestFixtureFunctions(plugin_base.FixtureFunctions): def skip_test_exception(self, *arg, **kw): return pytest.skip.Exception(*arg, **kw) @@ -326,8 +377,6 @@ class PytestFixtureFunctions(plugin_base.FixtureFunctions): argnames = kw.pop("argnames", None) - exclusion_combinations = [] - def _filter_exclusions(args): result = [] gathered_exclusions = [] @@ -337,13 +386,12 @@ class PytestFixtureFunctions(plugin_base.FixtureFunctions): else: result.append(a) - exclusion_combinations.extend( - [(exclusion, result) for exclusion in gathered_exclusions] - ) - return result + return result, gathered_exclusions id_ = kw.pop("id_", None) + tobuild_pytest_params = [] + has_exclusions = False if id_: _combination_id_fns = self._combination_id_fns @@ -364,53 +412,87 @@ class PytestFixtureFunctions(plugin_base.FixtureFunctions): if char in _combination_id_fns ] - arg_sets = [ - pytest.param( - *_arg_getter(_filter_exclusions(arg))[1:], - id="-".join( - comb_fn(getter(arg)) for getter, comb_fn in fns + for arg in arg_sets: + if not isinstance(arg, tuple): + arg = (arg,) + + fn_params, param_exclusions = _filter_exclusions(arg) + + parameters = _arg_getter(fn_params)[1:] + + if param_exclusions: + has_exclusions = True + + tobuild_pytest_params.append( + ( + parameters, + param_exclusions, + "-".join( + comb_fn(getter(arg)) for getter, comb_fn in fns + ), ) ) - for arg in [ - (arg,) if not isinstance(arg, tuple) else arg - for arg in arg_sets - ] - ] + else: - # ensure using pytest.param so that even a 1-arg paramset - # still needs to be a tuple. otherwise paramtrize tries to - # interpret a single arg differently than tuple arg - arg_sets = [ - pytest.param(*_filter_exclusions(arg)) - for arg in [ - (arg,) if not isinstance(arg, tuple) else arg - for arg in arg_sets - ] - ] + + for arg in arg_sets: + if not isinstance(arg, tuple): + arg = (arg,) + + fn_params, param_exclusions = _filter_exclusions(arg) + + if param_exclusions: + has_exclusions = True + + tobuild_pytest_params.append( + (fn_params, param_exclusions, None) + ) + + pytest_params = [] + for parameters, param_exclusions, id_ in tobuild_pytest_params: + if has_exclusions: + parameters += (param_exclusions,) + + param = pytest.param(*parameters, id=id_) + pytest_params.append(param) def decorate(fn): if inspect.isclass(fn): + if has_exclusions: + raise NotImplementedError( + "exclusions not supported for class level combinations" + ) if "_sa_parametrize" not in fn.__dict__: fn._sa_parametrize = [] - fn._sa_parametrize.append((argnames, arg_sets)) + fn._sa_parametrize.append((argnames, pytest_params)) return fn else: if argnames is None: - _argnames = getargspec(fn).args[1:] + _argnames = getargspec(fn).args[1:] # type: Sequence(str) else: - _argnames = argnames - - if exclusion_combinations: - for exclusion, combination in exclusion_combinations: - combination_by_kw = { - argname: val - for argname, val in zip(_argnames, combination) - } - exclusion = exclusion.with_combination( - **combination_by_kw - ) - fn = exclusion(fn) - return pytest.mark.parametrize(_argnames, arg_sets)(fn) + _argnames = re.split( + r", *", argnames + ) # type: Sequence(str) + + if has_exclusions: + _argnames += ["_exclusions"] + + @_pytest_fn_decorator + def check_exclusions(fn, *args, **kw): + _exclusions = args[-1] + if _exclusions: + exlu = exclusions.compound().add(*_exclusions) + fn = exlu(fn) + return fn(*args[0:-1], **kw) + + def process_metadata(spec): + spec.args.append("_exclusions") + + fn = check_exclusions( + fn, add_positional_parameters=("_exclusions",) + ) + + return pytest.mark.parametrize(_argnames, pytest_params)(fn) return decorate diff --git a/lib/sqlalchemy/testing/profiling.py b/lib/sqlalchemy/testing/profiling.py index cc6557018..0026b5f8c 100644 --- a/lib/sqlalchemy/testing/profiling.py +++ b/lib/sqlalchemy/testing/profiling.py @@ -220,7 +220,7 @@ class ProfileStatsFile(object): profile_f.close() -def function_call_count(variance=0.05, times=1): +def function_call_count(variance=0.05, times=1, warmup=0): """Assert a target for a test case's function call count. The main purpose of this assertion is to detect changes in @@ -239,6 +239,9 @@ def function_call_count(variance=0.05, times=1): @decorator def wrap(fn, *args, **kw): + for warm in range(warmup): + fn(*args, **kw) + timerange = range(times) with count_functions(variance=variance): for time in timerange: diff --git a/lib/sqlalchemy/testing/requirements.py b/lib/sqlalchemy/testing/requirements.py index 03d76eccb..c12d1e6e8 100644 --- a/lib/sqlalchemy/testing/requirements.py +++ b/lib/sqlalchemy/testing/requirements.py @@ -1029,6 +1029,13 @@ class SuiteRequirements(Requirements): ) @property + def python37(self): + return exclusions.skip_if( + lambda: sys.version_info < (3, 7), + "Python version 3.7 or greater is required.", + ) + + @property def cpython(self): return exclusions.only_if( lambda: util.cpython, "cPython interpreter needed" diff --git a/lib/sqlalchemy/util/compat.py b/lib/sqlalchemy/util/compat.py index ea9ac0f11..8967955cd 100644 --- a/lib/sqlalchemy/util/compat.py +++ b/lib/sqlalchemy/util/compat.py @@ -270,7 +270,18 @@ else: if py35: - from inspect import formatannotation + + def _formatannotation(annotation, base_module=None): + """vendored from python 3.7 + """ + + if getattr(annotation, "__module__", None) == "typing": + return repr(annotation).replace("typing.", "") + if isinstance(annotation, type): + if annotation.__module__ in ("builtins", base_module): + return annotation.__qualname__ + return annotation.__module__ + "." + annotation.__qualname__ + return repr(annotation) def inspect_formatargspec( args, @@ -285,7 +296,7 @@ if py35: formatvarkw=lambda name: "**" + name, formatvalue=lambda value: "=" + repr(value), formatreturns=lambda text: " -> " + text, - formatannotation=formatannotation, + formatannotation=_formatannotation, ): """Copy formatargspec from python 3.7 standard library. diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py index 402f8bb09..41a9698c7 100644 --- a/lib/sqlalchemy/util/langhelpers.py +++ b/lib/sqlalchemy/util/langhelpers.py @@ -170,7 +170,7 @@ def _exec_code_in_env(code, env, fn_name): return env[fn_name] -def public_factory(target, location): +def public_factory(target, location, class_location=None): """Produce a wrapping function for the given cls or classmethod. Rationale here is so that the __init__ method of the @@ -183,14 +183,14 @@ def public_factory(target, location): doc = ( "Construct a new :class:`.%s` object. \n\n" "This constructor is mirrored as a public API function; " - "see :func:`~%s` " + "see :func:`sqlalchemy%s` " "for a full usage and argument description." % (target.__name__, location) ) else: fn = callable_ = target doc = ( - "This function is mirrored; see :func:`~%s` " + "This function is mirrored; see :func:`sqlalchemy%s` " "for a description of arguments." % location ) @@ -209,12 +209,38 @@ def %(name)s(%(args)s): env = {"cls": callable_, "symbol": symbol} exec(code, env) decorated = env[location_name] - decorated.__doc__ = fn.__doc__ + if hasattr(fn, "_linked_to"): + linked_to, linked_to_location = fn._linked_to + linked_to_doc = linked_to.__doc__ + if class_location is None: + class_location = "%s.%s" % (target.__module__, target.__name__) + + linked_to_doc = inject_docstring_text( + linked_to_doc, + ".. container:: inherited_member\n\n " + "Inherited from :func:`sqlalchemy%s`; this constructor " + "creates a :class:`%s` object" + % (linked_to_location, class_location), + 0, + ) + decorated.__doc__ = linked_to_doc + else: + decorated.__doc__ = fn.__doc__ + decorated.__module__ = "sqlalchemy" + location.rsplit(".", 1)[0] + if decorated.__module__ not in sys.modules: + raise ImportError( + "public_factory location %s is not in sys.modules" + % (decorated.__module__,) + ) if compat.py2k or hasattr(fn, "__func__"): fn.__func__.__doc__ = doc + if not hasattr(fn.__func__, "_linked_to"): + fn.__func__._linked_to = (decorated, location) else: fn.__doc__ = doc + if not hasattr(fn, "_linked_to"): + fn._linked_to = (decorated, location) return decorated diff --git a/regen_callcounts.tox.ini b/regen_callcounts.tox.ini index 7c2cd3936..87153511f 100644 --- a/regen_callcounts.tox.ini +++ b/regen_callcounts.tox.ini @@ -30,6 +30,7 @@ setenv= PYTHONPATH= PYTHONNOUSERSITE=1 sqla_nocext: DISABLE_SQLALCHEMY_CEXT=1 + cext: REQUIRE_SQLALCHEMY_CEXT=1 db_sqlite: SQLITE={env:TOX_SQLITE:--db sqlite} db_postgresql: POSTGRESQL={env:TOX_POSTGRESQL:--db postgresql} db_mysql: MYSQL={env:TOX_MYSQL:--db mysql --db pymysql} diff --git a/test/aaa_profiling/test_misc.py b/test/aaa_profiling/test_misc.py index fdb40c2e6..8326a3190 100644 --- a/test/aaa_profiling/test_misc.py +++ b/test/aaa_profiling/test_misc.py @@ -17,7 +17,7 @@ from sqlalchemy.util import classproperty class EnumTest(fixtures.TestBase): - __requires__ = ("cpython",) + __requires__ = ("cpython", "python_profiling_backend") def setup(self): class SomeEnum(object): @@ -50,7 +50,7 @@ class EnumTest(fixtures.TestBase): class CacheKeyTest(fixtures.TestBase): - __requires__ = ("cpython",) + __requires__ = ("cpython", "python_profiling_backend") @testing.fixture(scope="class") def mapping_fixture(self): diff --git a/test/aaa_profiling/test_orm.py b/test/aaa_profiling/test_orm.py index 58c7de7ed..afa8634aa 100644 --- a/test/aaa_profiling/test_orm.py +++ b/test/aaa_profiling/test_orm.py @@ -25,6 +25,8 @@ from sqlalchemy.testing.schema import Table class MergeTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -101,7 +103,7 @@ class MergeTest(fixtures.MappedTest): sess2.transaction # autobegin - @profiling.function_call_count(variance=0.10) + @profiling.function_call_count(variance=0.10, warmup=1) def go2(): return sess2.merge(p2, load=False) @@ -147,6 +149,8 @@ class LoadManyToOneFromIdentityTest(fixtures.MappedTest): """ + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -232,6 +236,8 @@ class LoadManyToOneFromIdentityTest(fixtures.MappedTest): class MergeBackrefsTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -324,6 +330,8 @@ class MergeBackrefsTest(fixtures.MappedTest): class DeferOptionsTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -386,6 +394,8 @@ class DeferOptionsTest(fixtures.MappedTest): class AttributeOverheadTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -463,6 +473,8 @@ class AttributeOverheadTest(fixtures.MappedTest): class SessionTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -527,6 +539,8 @@ class SessionTest(fixtures.MappedTest): class QueryTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -594,6 +608,8 @@ class SelectInEagerLoadTest(fixtures.MappedTest): """ + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): @@ -672,6 +688,8 @@ class SelectInEagerLoadTest(fixtures.MappedTest): class JoinedEagerLoadTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): def make_some_columns(): @@ -829,6 +847,8 @@ class JoinedEagerLoadTest(fixtures.MappedTest): class JoinConditionTest(fixtures.DeclarativeMappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def setup_classes(cls): class A(cls.DeclarativeBasic): @@ -871,7 +891,7 @@ class JoinConditionTest(fixtures.DeclarativeMappedTest): A, B = self.classes("A", "B") # should not use aliasing or adaption so should be cheap - @profiling.function_call_count(times=50) + @profiling.function_call_count(times=50, warmup=1) def go(): orm_join(A, B, A.b) @@ -883,7 +903,7 @@ class JoinConditionTest(fixtures.DeclarativeMappedTest): a1 = aliased(A) # uses aliasing, therefore adaption which is expensive - @profiling.function_call_count(times=50) + @profiling.function_call_count(times=50, warmup=1) def go(): orm_join(a1, B, a1.b) @@ -896,7 +916,7 @@ class JoinConditionTest(fixtures.DeclarativeMappedTest): # overlap so incurs aliasing, which is expensive, there is also a check # that determines that this overlap exists which is not currently # cached - @profiling.function_call_count(times=50) + @profiling.function_call_count(times=50, warmup=1) def go(): orm_join(A, D, A.d) @@ -908,7 +928,7 @@ class JoinConditionTest(fixtures.DeclarativeMappedTest): a1 = aliased(A) # aliased, uses adaption therefore expensive - @profiling.function_call_count(times=50) + @profiling.function_call_count(times=50, warmup=1) def go(): orm_join(a1, D, a1.d) @@ -916,6 +936,8 @@ class JoinConditionTest(fixtures.DeclarativeMappedTest): class BranchedOptionTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): def make_some_columns(): @@ -1044,7 +1066,7 @@ class BranchedOptionTest(fixtures.MappedTest): cache_path = inspect(A)._path_registry - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for opt in opts: opt._generate_path_cache_key(cache_path) @@ -1064,7 +1086,7 @@ class BranchedOptionTest(fixtures.MappedTest): cache_path = inspect(A)._path_registry - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for opt in opts: opt._generate_path_cache_key(cache_path) @@ -1084,7 +1106,7 @@ class BranchedOptionTest(fixtures.MappedTest): q = Session().query(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): q.options(*opts) @@ -1103,7 +1125,7 @@ class BranchedOptionTest(fixtures.MappedTest): q = Session().query(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): q.options(*opts) @@ -1111,6 +1133,8 @@ class BranchedOptionTest(fixtures.MappedTest): class AnnotatedOverheadTest(fixtures.MappedTest): + __requires__ = ("python_profiling_backend",) + @classmethod def define_tables(cls, metadata): Table( @@ -1147,7 +1171,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): q = s.query(A).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1161,7 +1185,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): q = s.query(a.c.data).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1173,7 +1197,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(A.data).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1185,7 +1209,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(A, A.data).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1198,7 +1222,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(A, a.c.data).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1211,7 +1235,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(a.c.data, A).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1223,7 +1247,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(A.data, A).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1236,7 +1260,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(Bundle("ASdf", a.c.data), A).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() @@ -1248,7 +1272,7 @@ class AnnotatedOverheadTest(fixtures.MappedTest): s = Session() q = s.query(Bundle("ASdf", A.data), A).select_from(A) - @profiling.function_call_count() + @profiling.function_call_count(warmup=1) def go(): for i in range(100): q.all() diff --git a/test/aaa_profiling/test_pool.py b/test/aaa_profiling/test_pool.py index 538eee45d..fd02f9139 100644 --- a/test/aaa_profiling/test_pool.py +++ b/test/aaa_profiling/test_pool.py @@ -8,7 +8,7 @@ pool = None class QueuePoolTest(fixtures.TestBase, AssertsExecutionResults): - __requires__ = ("cpython",) + __requires__ = ("cpython", "python_profiling_backend") class Connection(object): def rollback(self): diff --git a/test/dialect/mssql/test_compiler.py b/test/dialect/mssql/test_compiler.py index 07ceb5bf5..b7a06c8e3 100644 --- a/test/dialect/mssql/test_compiler.py +++ b/test/dialect/mssql/test_compiler.py @@ -370,8 +370,8 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): ) def test_noorderby_insubquery(self): - """test that the ms-sql dialect removes ORDER BY clauses from - subqueries""" + """test "no ORDER BY in subqueries unless TOP / LIMIT / OFFSET" + present""" table1 = table( "mytable", @@ -389,6 +389,112 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): "foo.myid = mytable.myid", ) + def test_noorderby_insubquery_limit(self): + """test "no ORDER BY in subqueries unless TOP / LIMIT / OFFSET" + present""" + + table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), + ) + + q = ( + select([table1.c.myid], order_by=[table1.c.myid]) + .limit(10) + .alias("foo") + ) + crit = q.c.myid == table1.c.myid + self.assert_compile( + select(["*"], crit), + "SELECT * FROM (SELECT TOP [POSTCOMPILE_param_1] mytable.myid AS " + "myid FROM mytable ORDER BY mytable.myid) AS foo, mytable WHERE " + "foo.myid = mytable.myid", + ) + + def test_noorderby_insubquery_offset_oldstyle(self): + """test "no ORDER BY in subqueries unless TOP / LIMIT / OFFSET" + present""" + + table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), + ) + + q = ( + select([table1.c.myid], order_by=[table1.c.myid]) + .offset(10) + .alias("foo") + ) + crit = q.c.myid == table1.c.myid + self.assert_compile( + select(["*"], crit), + "SELECT * FROM (SELECT anon_1.myid AS myid FROM " + "(SELECT mytable.myid AS myid, ROW_NUMBER() OVER (ORDER BY " + "mytable.myid) AS mssql_rn FROM mytable) AS anon_1 " + "WHERE mssql_rn > :param_1) AS foo, mytable WHERE " + "foo.myid = mytable.myid", + ) + + def test_noorderby_insubquery_offset_newstyle(self): + """test "no ORDER BY in subqueries unless TOP / LIMIT / OFFSET" + present""" + + table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), + ) + + q = ( + select([table1.c.myid], order_by=[table1.c.myid]) + .offset(10) + .alias("foo") + ) + crit = q.c.myid == table1.c.myid + dialect = mssql.dialect() + dialect._supports_offset_fetch = True + self.assert_compile( + select(["*"], crit), + "SELECT * FROM (SELECT mytable.myid AS myid FROM mytable " + "ORDER BY mytable.myid OFFSET :param_1 ROWS) AS foo, " + "mytable WHERE foo.myid = mytable.myid", + dialect=dialect, + ) + + def test_noorderby_insubquery_limit_offset_newstyle(self): + """test "no ORDER BY in subqueries unless TOP / LIMIT / OFFSET" + present""" + + table1 = table( + "mytable", + column("myid", Integer), + column("name", String), + column("description", String), + ) + + q = ( + select([table1.c.myid], order_by=[table1.c.myid]) + .limit(10) + .offset(10) + .alias("foo") + ) + crit = q.c.myid == table1.c.myid + dialect = mssql.dialect() + dialect._supports_offset_fetch = True + self.assert_compile( + select(["*"], crit), + "SELECT * FROM (SELECT mytable.myid AS myid FROM mytable " + "ORDER BY mytable.myid OFFSET :param_1 ROWS " + "FETCH NEXT :param_2 ROWS ONLY ) AS foo, " + "mytable WHERE foo.myid = mytable.myid", + dialect=dialect, + ) + def test_noorderby_parameters_insubquery(self): """test that the ms-sql dialect does not include ORDER BY positional parameters in subqueries""" @@ -859,7 +965,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL): "OFFSET :param_1 ROWS " "FETCH NEXT :param_2 ROWS ONLY ", checkparams={"param_1": 20, "param_2": 10, "x_1": 5}, - dialect=dialect_2012 + dialect=dialect_2012, ) c = s.compile(dialect=dialect_2012) diff --git a/test/dialect/mssql/test_types.py b/test/dialect/mssql/test_types.py index 3cf9d9036..92d3d9e32 100644 --- a/test/dialect/mssql/test_types.py +++ b/test/dialect/mssql/test_types.py @@ -41,6 +41,7 @@ from sqlalchemy.dialects.mssql.base import MS_2005_VERSION from sqlalchemy.dialects.mssql.base import MS_2008_VERSION from sqlalchemy.dialects.mssql.base import TIME from sqlalchemy.sql import sqltypes +from sqlalchemy.testing import assert_raises from sqlalchemy.testing import assert_raises_message from sqlalchemy.testing import AssertsCompiledSQL from sqlalchemy.testing import AssertsExecutionResults @@ -709,69 +710,159 @@ class TypeRoundTripTest( for col in reflected_dates.c: self.assert_types_base(col, dates_table.c[col.key]) - def test_date_roundtrip(self): + @testing.metadata_fixture() + def date_fixture(self, metadata): t = Table( "test_dates", metadata, - Column( - "id", - Integer, - Sequence("datetest_id_seq", optional=True), - primary_key=True, - ), Column("adate", Date), - Column("atime", Time), + Column("atime1", Time), + Column("atime2", Time), Column("adatetime", DateTime), Column("adatetimeoffset", DATETIMEOFFSET), ) - metadata.create_all() + d1 = datetime.date(2007, 10, 30) t1 = datetime.time(11, 2, 32) d2 = datetime.datetime(2007, 10, 30, 11, 2, 32) - dto = datetime.datetime( - 2007, - 10, - 30, - 11, - 2, - 32, - 123456, - util.timezone(datetime.timedelta(hours=1)), - ) - t.insert().execute( - adate=d1, adatetime=d2, atime=t1, adatetimeoffset=dto - ) - - # NOTE: this previously passed 'd2' for "adate" even though - # "adate" is a date column; we asserted that it truncated w/o issue. - # As of pyodbc 4.0.22, this is no longer accepted, was accepted - # in 4.0.21. See also the new pyodbc assertions regarding numeric - # precision. - t.insert().execute( - adate=d1, adatetime=d2, atime=d2, adatetimeoffset=dto - ) + return t, (d1, t1, d2) - x = t.select().execute().fetchall()[0] - self.assert_(x.adate.__class__ == datetime.date) - self.assert_(x.atime.__class__ == datetime.time) - self.assert_(x.adatetime.__class__ == datetime.datetime) - self.assert_(x.adatetimeoffset.__class__ == datetime.datetime) + def test_date_roundtrips(self, date_fixture): + t, (d1, t1, d2) = date_fixture + with testing.db.begin() as conn: + conn.execute( + t.insert(), adate=d1, adatetime=d2, atime1=t1, atime2=d2 + ) - t.delete().execute() + row = conn.execute(t.select()).first() + eq_( + (row.adate, row.adatetime, row.atime1, row.atime2), + (d1, d2, t1, d2.time()), + ) - t.insert().execute( - adate=d1, adatetime=d2, atime=t1, adatetimeoffset=dto + @testing.metadata_fixture() + def datetimeoffset_fixture(self, metadata): + t = Table( + "test_dates", metadata, Column("adatetimeoffset", DATETIMEOFFSET), ) - eq_( - select( - [t.c.adate, t.c.atime, t.c.adatetime, t.c.adatetimeoffset], - t.c.adate == d1, + return t + + @testing.combinations( + ("dto_param_none", lambda: None, None, False), + ( + "dto_param_datetime_aware_positive", + lambda: datetime.datetime( + 2007, + 10, + 30, + 11, + 2, + 32, + 123456, + util.timezone(datetime.timedelta(hours=1)), + ), + 1, + False, + ), + ( + "dto_param_datetime_aware_negative", + lambda: datetime.datetime( + 2007, + 10, + 30, + 11, + 2, + 32, + 123456, + util.timezone(datetime.timedelta(hours=-5)), + ), + -5, + False, + ), + ( + "dto_param_datetime_aware_seconds_frac_fail", + lambda: datetime.datetime( + 2007, + 10, + 30, + 11, + 2, + 32, + 123456, + util.timezone(datetime.timedelta(seconds=4000)), + ), + None, + True, + testing.requires.python37, + ), + ( + "dto_param_datetime_naive", + lambda: datetime.datetime(2007, 10, 30, 11, 2, 32, 123456), + 0, + False, + ), + ( + "dto_param_string_one", + lambda: "2007-10-30 11:02:32.123456 +01:00", + 1, + False, + ), + # wow + ( + "dto_param_string_two", + lambda: "October 30, 2007 11:02:32.123456", + 0, + False, + ), + ("dto_param_string_invalid", lambda: "this is not a date", 0, True), + id_="iaaa", + argnames="dto_param_value, expected_offset_hours, should_fail", + ) + def test_datetime_offset( + self, + datetimeoffset_fixture, + dto_param_value, + expected_offset_hours, + should_fail, + ): + t = datetimeoffset_fixture + dto_param_value = dto_param_value() + + with testing.db.begin() as conn: + if should_fail: + assert_raises( + sa.exc.DBAPIError, + conn.execute, + t.insert(), + adatetimeoffset=dto_param_value, + ) + return + + conn.execute( + t.insert(), adatetimeoffset=dto_param_value, ) - .execute() - .fetchall(), - [(d1, t1, d2, dto)], - ) + + row = conn.execute(t.select()).first() + + if dto_param_value is None: + is_(row.adatetimeoffset, None) + else: + eq_( + row.adatetimeoffset, + datetime.datetime( + 2007, + 10, + 30, + 11, + 2, + 32, + 123456, + util.timezone( + datetime.timedelta(hours=expected_offset_hours) + ), + ), + ) @emits_warning_on("mssql+mxodbc", r".*does not have any indexes.*") @testing.provide_metadata diff --git a/test/orm/test_defaults.py b/test/orm/test_defaults.py index 07b82b9da..5cadea5ff 100644 --- a/test/orm/test_defaults.py +++ b/test/orm/test_defaults.py @@ -263,7 +263,13 @@ class ComputedDefaultsOnUpdateTest(fixtures.MappedTest): ) @testing.combinations( - (True, testing.requires.computed_columns_on_update_returning), (False,) + ( + "eagerload", + True, + testing.requires.computed_columns_on_update_returning, + ), + ("noneagerload", False,), + id_="ia", ) def test_update_computed(self, eager): if eager: diff --git a/test/orm/test_relationships.py b/test/orm/test_relationships.py index c7a94e9ab..78e9d77e8 100644 --- a/test/orm/test_relationships.py +++ b/test/orm/test_relationships.py @@ -2703,6 +2703,12 @@ class ViewOnlyHistoryTest(fixtures.MappedTest): ) mapper(B, self.tables.t2) + with testing.expect_warnings( + "Setting backref / back_populates on " + "relationship B.a to refer to viewonly relationship A.bs" + ): + configure_mappers() + a1 = A() b1 = B() a1.bs.append(b1) @@ -2734,6 +2740,12 @@ class ViewOnlyHistoryTest(fixtures.MappedTest): ) mapper(B, self.tables.t2) + with testing.expect_warnings( + "Setting backref / back_populates on " + "relationship A.bs to refer to viewonly relationship B.a" + ): + configure_mappers() + a1 = A() b1 = B() b1.a = a1 @@ -2834,6 +2846,12 @@ class ViewOnlyM2MBackrefTest(fixtures.MappedTest): ) mapper(B, t2) + with testing.expect_warnings( + "Setting backref / back_populates on " + "relationship A.bs to refer to viewonly relationship B.a" + ): + configure_mappers() + sess = create_session() a1 = A() b1 = B(as_=[a1]) diff --git a/test/profiles.txt b/test/profiles.txt index 41f1fab7a..043e7e5a0 100644 --- a/test/profiles.txt +++ b/test/profiles.txt @@ -1,15 +1,15 @@ # /home/classic/dev/sqlalchemy/test/profiles.txt # This file is written out on a per-environment basis. -# For each test in aaa_profiling, the corresponding function and +# For each test in aaa_profiling, the corresponding function and # environment is located within this file. If it doesn't exist, # the test is skipped. -# If a callcount does exist, it is compared to what we received. +# If a callcount does exist, it is compared to what we received. # assertions are raised if the counts do not match. -# -# To add a new callcount test, apply the function_call_count -# decorator and re-run the tests using the --write-profiles +# +# To add a new callcount test, apply the function_call_count +# decorator and re-run the tests using the --write-profiles # option - this file will be rewritten including the new count. -# +# # TEST: test.aaa_profiling.test_compiler.CompileTest.test_insert @@ -19,10 +19,10 @@ test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapi test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_mysql_pymysql_dbapiunicode_nocextensions 66 test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_cextensions 66 test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 66 -test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_cextensions 66 +test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_cextensions 65 test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 66 -test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_cextensions 66 -test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 66 +test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_cextensions 65 +test.aaa_profiling.test_compiler.CompileTest.test_insert 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 65 test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_cextensions 71 test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mssql_pyodbc_dbapiunicode_nocextensions 71 test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_mysql_mysqldb_dbapiunicode_cextensions 71 @@ -33,8 +33,8 @@ test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_db test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 71 test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_cextensions 71 test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 71 -test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_cextensions 71 -test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 71 +test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_cextensions 70 +test.aaa_profiling.test_compiler.CompileTest.test_insert 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 70 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_select @@ -44,10 +44,10 @@ test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapi test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_mysql_pymysql_dbapiunicode_nocextensions 161 test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_cextensions 163,161 test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 161 -test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_cextensions 161 +test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_cextensions 163 test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 161 -test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_cextensions 161 -test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 161 +test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_cextensions 163 +test.aaa_profiling.test_compiler.CompileTest.test_select 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 163 test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_cextensions 174 test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mssql_pyodbc_dbapiunicode_nocextensions 174 test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_mysql_mysqldb_dbapiunicode_cextensions 174 @@ -58,8 +58,8 @@ test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_db test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 174 test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_cextensions 174 test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 174 -test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_cextensions 174 -test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 174 +test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_cextensions 176 +test.aaa_profiling.test_compiler.CompileTest.test_select 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 176 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_select_labels @@ -94,10 +94,10 @@ test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapi test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_mysql_pymysql_dbapiunicode_nocextensions 76 test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_cextensions 82,80 test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 78 -test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_cextensions 78 +test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_cextensions 77 test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 78 -test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_cextensions 78 -test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 78 +test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_cextensions 77 +test.aaa_profiling.test_compiler.CompileTest.test_update 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 77 test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_cextensions 81 test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mssql_pyodbc_dbapiunicode_nocextensions 81 test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_mysql_mysqldb_dbapiunicode_cextensions 81 @@ -108,8 +108,8 @@ test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_db test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 81 test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_cextensions 81 test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 81 -test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_cextensions 81 -test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 81 +test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_cextensions 80 +test.aaa_profiling.test_compiler.CompileTest.test_update 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 80 # TEST: test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause @@ -138,717 +138,248 @@ test.aaa_profiling.test_compiler.CompileTest.test_update_whereclause 3.7_sqlite_ # TEST: test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one -test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 4876 +test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one 2.7_sqlite_pysqlite_dbapiunicode_cextensions 4968 +test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 4968 +test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one 3.7_sqlite_pysqlite_dbapiunicode_cextensions 5173 test.aaa_profiling.test_misc.CacheKeyTest.test_statement_one 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 5173 # 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 2.7_mssql_pyodbc_dbapiunicode_nocextensions 1325 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_mysql_pymysql_dbapiunicode_nocextensions 1325 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 1325 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_postgresql_psycopg2_dbapiunicode_cextensions 1325 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 1325 test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1325 test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1325 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_mssql_pyodbc_dbapiunicode_cextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_mssql_pyodbc_dbapiunicode_nocextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_mysql_pymysql_dbapiunicode_cextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_mysql_pymysql_dbapiunicode_nocextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_oracle_cx_oracle_dbapiunicode_cextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_postgresql_psycopg2_dbapiunicode_cextensions 925 -test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 925 test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_sqlite_pysqlite_dbapiunicode_cextensions 925 test.aaa_profiling.test_misc.EnumTest.test_create_enum_from_pep_435_w_expensive_members 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 925 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_mssql_pyodbc_dbapiunicode_nocextensions 55503 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_mysql_pymysql_dbapiunicode_nocextensions 101008 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_oracle_cx_oracle_dbapiunicode_cextensions 52014 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 58824 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 49415 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 54203 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 49001 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 53789 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mssql_pyodbc_dbapiunicode_cextensions 52706 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mssql_pyodbc_dbapiunicode_nocextensions 57706 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mysql_mysqldb_dbapiunicode_cextensions 54378 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mysql_mysqldb_dbapiunicode_nocextensions 57978 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mysql_pymysql_dbapiunicode_cextensions 88111 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_mysql_pymysql_dbapiunicode_nocextensions 93511 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_oracle_cx_oracle_dbapiunicode_cextensions 53827 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 59227 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 51906 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 57306 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 51000 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 56400 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 49105 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 54205 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 51005 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_w_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 56405 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_mssql_pyodbc_dbapiunicode_nocextensions 54873 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_mysql_pymysql_dbapiunicode_nocextensions 100372 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_oracle_cx_oracle_dbapiunicode_cextensions 51972 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 58173 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 48773 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 53573 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48357 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 53157 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mssql_pyodbc_dbapiunicode_cextensions 52065 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mssql_pyodbc_dbapiunicode_nocextensions 57065 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mysql_mysqldb_dbapiunicode_cextensions 54364 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mysql_mysqldb_dbapiunicode_nocextensions 57964 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mysql_pymysql_dbapiunicode_cextensions 87464 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_mysql_pymysql_dbapiunicode_nocextensions 92864 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_oracle_cx_oracle_dbapiunicode_cextensions 53165 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 58565 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 51265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 56665 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 50357 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 55757 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48605 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 53705 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_cextensions 50505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_bundle_wo_annotation 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 55905 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 53178 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 98677 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 49677 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 56478 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 47078 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 51878 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46662 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51462 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 49773 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 54773 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 51472 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 55072 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 85172 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 90572 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 50873 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 56273 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 48973 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 54373 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48065 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53465 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46905 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52005 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48205 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53605 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 52673 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 98172 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 49772 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 55973 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 46573 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 51373 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46157 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 50957 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 49265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 54265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 51564 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 55164 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 84664 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 90064 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 50365 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 55765 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 48465 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 53865 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47557 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 52957 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46405 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47705 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53105 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_mssql_pyodbc_dbapiunicode_nocextensions 45273 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_mysql_pymysql_dbapiunicode_nocextensions 90772 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_oracle_cx_oracle_dbapiunicode_cextensions 41972 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 48573 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_postgresql_psycopg2_dbapiunicode_cextensions 39673 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 43973 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_cextensions 39257 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 43557 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mssql_pyodbc_dbapiunicode_cextensions 42865 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mssql_pyodbc_dbapiunicode_nocextensions 47765 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mysql_mysqldb_dbapiunicode_cextensions 44664 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mysql_mysqldb_dbapiunicode_nocextensions 47364 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mysql_pymysql_dbapiunicode_cextensions 78664 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_mysql_pymysql_dbapiunicode_nocextensions 83564 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_oracle_cx_oracle_dbapiunicode_cextensions 44365 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 49265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_postgresql_psycopg2_dbapiunicode_cextensions 42065 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 46965 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_cextensions 41157 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 46057 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_cextensions 39505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 44105 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_cextensions 41705 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 46605 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 53178 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 98677 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 49677 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 56478 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 47078 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 51878 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46662 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51462 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 49773 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 54773 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 51472 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 55072 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 85172 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 90572 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 50873 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 56273 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 48973 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 54373 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48065 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53465 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46905 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52005 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 48205 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53605 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 52673 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 98172 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 49772 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 55973 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 46573 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 51373 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46157 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 50957 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 49265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 54265 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 51564 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 55164 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 84664 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 90064 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 50365 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 55765 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 48465 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 53865 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47557 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 52957 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 46405 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 51505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 47705 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_bundle_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 53105 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 29720 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 63819 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 27319 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 31620 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 26620 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 28620 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26204 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 28204 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 30210 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 32010 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 31009 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 33109 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 56509 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 58709 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 29910 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 32110 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 29410 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 31610 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28702 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30902 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 28505 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28605 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_w_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30805 # TEST: test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_mssql_pyodbc_dbapiunicode_nocextensions 29220 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_mysql_pymysql_dbapiunicode_nocextensions 63319 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_cextensions 27419 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 31120 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_cextensions 26120 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 28120 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 25704 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 27704 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_cextensions 29710 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mssql_pyodbc_dbapiunicode_nocextensions 31510 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_cextensions 31109 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mysql_mysqldb_dbapiunicode_nocextensions 33209 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mysql_pymysql_dbapiunicode_cextensions 56009 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_mysql_pymysql_dbapiunicode_nocextensions 58209 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_cextensions 29410 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 31610 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_cextensions 28910 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 31110 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28202 -test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30402 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_cextensions 26005 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 28005 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_cextensions 28105 +test.aaa_profiling.test_orm.AnnotatedOverheadTest.test_no_entity_wo_annotations 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30305 # TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_mssql_pyodbc_dbapiunicode_cextensions 3927 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_mssql_pyodbc_dbapiunicode_nocextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_mysql_pymysql_dbapiunicode_nocextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_oracle_cx_oracle_dbapiunicode_cextensions 3927 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_postgresql_psycopg2_dbapiunicode_cextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3812 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mssql_pyodbc_dbapiunicode_cextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mssql_pyodbc_dbapiunicode_nocextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mysql_mysqldb_dbapiunicode_cextensions 4047 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mysql_mysqldb_dbapiunicode_nocextensions 4047 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mysql_pymysql_dbapiunicode_cextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_mysql_pymysql_dbapiunicode_nocextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_oracle_cx_oracle_dbapiunicode_cextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_postgresql_psycopg2_dbapiunicode_cextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_cextensions 3933 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3933 +test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3807 +test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3807 +test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_cextensions 3928 +test.aaa_profiling.test_orm.AttributeOverheadTest.test_attribute_set 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3928 # TEST: test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_mssql_pyodbc_dbapiunicode_cextensions 6222 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6026 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_mysql_pymysql_dbapiunicode_nocextensions 6026 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_oracle_cx_oracle_dbapiunicode_cextensions 6222 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 6026 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6026 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6026 test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_sqlite_pysqlite_dbapiunicode_cextensions 6026 test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6026 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mssql_pyodbc_dbapiunicode_cextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mysql_mysqldb_dbapiunicode_cextensions 6222 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mysql_mysqldb_dbapiunicode_nocextensions 6222 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mysql_pymysql_dbapiunicode_cextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_mysql_pymysql_dbapiunicode_nocextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_oracle_cx_oracle_dbapiunicode_cextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_postgresql_psycopg2_dbapiunicode_cextensions 6228 -test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6228 test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_sqlite_pysqlite_dbapiunicode_cextensions 6228 test.aaa_profiling.test_orm.AttributeOverheadTest.test_collection_append_remove 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6228 -# TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching - -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_mssql_pyodbc_dbapiunicode_nocextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_mysql_pymysql_dbapiunicode_nocextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 104 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_mssql_pyodbc_dbapiunicode_cextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_mssql_pyodbc_dbapiunicode_nocextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_mysql_pymysql_dbapiunicode_cextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_mysql_pymysql_dbapiunicode_nocextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_oracle_cx_oracle_dbapiunicode_cextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_postgresql_psycopg2_dbapiunicode_cextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 81 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 81 - -# TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching - -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_mssql_pyodbc_dbapiunicode_nocextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_mysql_pymysql_dbapiunicode_nocextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 718 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_mssql_pyodbc_dbapiunicode_cextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_mssql_pyodbc_dbapiunicode_nocextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_mysql_pymysql_dbapiunicode_cextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_mysql_pymysql_dbapiunicode_nocextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_oracle_cx_oracle_dbapiunicode_cextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_postgresql_psycopg2_dbapiunicode_cextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 695 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_cache_key_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 695 - # TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 104 test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 104 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 104 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 81 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 81 # TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 714 -test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 714 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 588 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 588 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 561 +test.aaa_profiling.test_orm.BranchedOptionTest.test_generate_path_cache_key_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 561 # 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 2.7_mssql_pyodbc_dbapiunicode_nocextensions 45 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_mysql_pymysql_dbapiunicode_nocextensions 45 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 45 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 45 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 45 test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 45 test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 45 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_mssql_pyodbc_dbapiunicode_cextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_mssql_pyodbc_dbapiunicode_nocextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_mysql_pymysql_dbapiunicode_cextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_mysql_pymysql_dbapiunicode_nocextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_oracle_cx_oracle_dbapiunicode_cextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_postgresql_psycopg2_dbapiunicode_cextensions 58 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 58 test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 58 test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_key_bound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 58 # TEST: test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_mssql_pyodbc_dbapiunicode_nocextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_mysql_pymysql_dbapiunicode_nocextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_postgresql_psycopg2_dbapiunicode_cextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 518 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_mssql_pyodbc_dbapiunicode_cextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_mssql_pyodbc_dbapiunicode_nocextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_mysql_pymysql_dbapiunicode_cextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_mysql_pymysql_dbapiunicode_nocextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_oracle_cx_oracle_dbapiunicode_cextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_postgresql_psycopg2_dbapiunicode_cextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 528 -test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 528 +test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_cextensions 388 +test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 388 +test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_cextensions 394 +test.aaa_profiling.test_orm.BranchedOptionTest.test_query_opts_unbound_branching 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 394 # TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_mssql_pyodbc_dbapiunicode_cextensions 17207 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_mssql_pyodbc_dbapiunicode_nocextensions 30224 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_mysql_pymysql_dbapiunicode_nocextensions 119888 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_oracle_cx_oracle_dbapiunicode_cextensions 17299 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 48328 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_postgresql_psycopg2_dbapiunicode_cextensions 17203 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 30201 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_cextensions 17183 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30181 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mssql_pyodbc_dbapiunicode_cextensions 17237 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mssql_pyodbc_dbapiunicode_nocextensions 30246 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mysql_mysqldb_dbapiunicode_cextensions 18218 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mysql_mysqldb_dbapiunicode_nocextensions 27225 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mysql_pymysql_dbapiunicode_cextensions 83754 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_mysql_pymysql_dbapiunicode_nocextensions 96763 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_oracle_cx_oracle_dbapiunicode_cextensions 17323 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 30332 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_postgresql_psycopg2_dbapiunicode_cextensions 17229 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 30238 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_cextensions 17202 -test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30211 +test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_cextensions 17102 +test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30108 +test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_cextensions 17129 +test.aaa_profiling.test_orm.DeferOptionsTest.test_baseline 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30138 # TEST: test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_mssql_pyodbc_dbapiunicode_cextensions 23235 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_mssql_pyodbc_dbapiunicode_nocextensions 30256 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_mysql_pymysql_dbapiunicode_nocextensions 59444 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_oracle_cx_oracle_dbapiunicode_cextensions 23247 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 30268 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_postgresql_psycopg2_dbapiunicode_cextensions 23265 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 30245 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 23245 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30225 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mssql_pyodbc_dbapiunicode_cextensions 23282 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mssql_pyodbc_dbapiunicode_nocextensions 30291 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mysql_mysqldb_dbapiunicode_cextensions 24287 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mysql_mysqldb_dbapiunicode_nocextensions 27294 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mysql_pymysql_dbapiunicode_cextensions 47431 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_mysql_pymysql_dbapiunicode_nocextensions 54440 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_oracle_cx_oracle_dbapiunicode_cextensions 23294 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 30303 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_postgresql_psycopg2_dbapiunicode_cextensions 23274 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 30283 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 23259 -test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30268 +test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 23249 +test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 30255 +test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 23289 +test.aaa_profiling.test_orm.DeferOptionsTest.test_defer_many_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 30298 # TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 2.7_postgresql_psycopg2_dbapiunicode_cextensions 9857 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 2.7_sqlite_pysqlite_dbapiunicode_cextensions 9857 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 10313 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 2.7_sqlite_pysqlite_dbapiunicode_cextensions 9903 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 9903 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 3.7_sqlite_pysqlite_dbapiunicode_cextensions 10354 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_aliased 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 10354 # TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 2.7_postgresql_psycopg2_dbapiunicode_cextensions 3555 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3555 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3556 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 2.7_sqlite_pysqlite_dbapiunicode_cextensions 3553 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 3553 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 3.7_sqlite_pysqlite_dbapiunicode_cextensions 3554 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_b_plain 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 3554 # TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 2.7_postgresql_psycopg2_dbapiunicode_cextensions 98722 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 2.7_sqlite_pysqlite_dbapiunicode_cextensions 98722 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 106798 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 2.7_sqlite_pysqlite_dbapiunicode_cextensions 99938 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 99938 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 3.7_sqlite_pysqlite_dbapiunicode_cextensions 107874 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 107874 # TEST: test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 2.7_postgresql_psycopg2_dbapiunicode_cextensions 96501 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 2.7_sqlite_pysqlite_dbapiunicode_cextensions 96501 -test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 104564 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 2.7_sqlite_pysqlite_dbapiunicode_cextensions 97538 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 97538 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 3.7_sqlite_pysqlite_dbapiunicode_cextensions 105739 +test.aaa_profiling.test_orm.JoinConditionTest.test_a_to_d_aliased 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 105739 # TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_postgresql_psycopg2_dbapiunicode_cextensions 462978 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_cextensions 469268 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 469263 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_cextensions 478410 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 478410 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_cextensions 466578 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 466573 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_cextensions 497244 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_build_query 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 497244 # TEST: test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_mssql_pyodbc_dbapiunicode_nocextensions 490606 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_mysql_pymysql_dbapiunicode_nocextensions 1211948 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 577188 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_postgresql_psycopg2_dbapiunicode_cextensions 466806 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 467106 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 463120 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 463420 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_mssql_pyodbc_dbapiunicode_cextensions 476716 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_mssql_pyodbc_dbapiunicode_nocextensions 495516 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_mysql_pymysql_dbapiunicode_cextensions 1028258 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_mysql_pymysql_dbapiunicode_nocextensions 1047058 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_oracle_cx_oracle_dbapiunicode_cextensions 563298 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 582098 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_postgresql_psycopg2_dbapiunicode_cextensions 469916 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 488716 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 451130 -test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 469930 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 457181 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 475681 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 461991 +test.aaa_profiling.test_orm.JoinedEagerLoadTest.test_fetch_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 480791 # 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 2.7_mssql_pyodbc_dbapiunicode_nocextensions 19986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_mysql_pymysql_dbapiunicode_nocextensions 19986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 19986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_postgresql_psycopg2_dbapiunicode_cextensions 19986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 19986 test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_sqlite_pysqlite_dbapiunicode_cextensions 19986 test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 19986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_mssql_pyodbc_dbapiunicode_cextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_mssql_pyodbc_dbapiunicode_nocextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_mysql_pymysql_dbapiunicode_cextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_mysql_pymysql_dbapiunicode_nocextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_oracle_cx_oracle_dbapiunicode_cextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_postgresql_psycopg2_dbapiunicode_cextensions 20986 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 20986 test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_sqlite_pysqlite_dbapiunicode_cextensions 20986 test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_identity 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 20986 # 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 2.7_mssql_pyodbc_dbapiunicode_nocextensions 91736 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_mysql_pymysql_dbapiunicode_nocextensions 173266 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 101273 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_postgresql_psycopg2_dbapiunicode_cextensions 91765 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 92515 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_cextensions 90467 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 91217 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_mssql_pyodbc_dbapiunicode_cextensions 90559 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_mssql_pyodbc_dbapiunicode_nocextensions 93813 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_mysql_pymysql_dbapiunicode_cextensions 154290 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_mysql_pymysql_dbapiunicode_nocextensions 157544 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_oracle_cx_oracle_dbapiunicode_cextensions 98547 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 101801 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_postgresql_psycopg2_dbapiunicode_cextensions 92289 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 95543 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_cextensions 90040 -test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 93294 +test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_cextensions 88227 +test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 91279 +test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_cextensions 90052 +test.aaa_profiling.test_orm.LoadManyToOneFromIdentityTest.test_many_to_one_load_no_identity 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 93306 # 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 2.7_mssql_pyodbc_dbapiunicode_nocextensions 18882 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_mysql_pymysql_dbapiunicode_nocextensions 24379 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 19476 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_postgresql_psycopg2_dbapiunicode_cextensions 18666 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 18714 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_cextensions 18530 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 18628 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_mssql_pyodbc_dbapiunicode_cextensions 19077 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_mssql_pyodbc_dbapiunicode_nocextensions 19513 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_mysql_pymysql_dbapiunicode_cextensions 23402 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_mysql_pymysql_dbapiunicode_nocextensions 23838 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_oracle_cx_oracle_dbapiunicode_cextensions 19671 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 20107 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_postgresql_psycopg2_dbapiunicode_cextensions 18965 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 19401 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_cextensions 18831 -test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 19267 +test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_cextensions 18356 +test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 18706 +test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_cextensions 18981 +test.aaa_profiling.test_orm.MergeBackrefsTest.test_merge_pending_with_all_pks 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 19417 # TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_load -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_mssql_pyodbc_dbapiunicode_cextensions 1045 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_mssql_pyodbc_dbapiunicode_nocextensions 1089 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_mysql_pymysql_dbapiunicode_nocextensions 2121 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_oracle_cx_oracle_dbapiunicode_cextensions 1111 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 1166 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_postgresql_psycopg2_dbapiunicode_cextensions 1152 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 1158 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1020 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1026 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mssql_pyodbc_dbapiunicode_cextensions 1089 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mssql_pyodbc_dbapiunicode_nocextensions 1120 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mysql_mysqldb_dbapiunicode_cextensions 1242 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mysql_mysqldb_dbapiunicode_nocextensions 1261 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mysql_pymysql_dbapiunicode_cextensions 1921 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_mysql_pymysql_dbapiunicode_nocextensions 1952 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_oracle_cx_oracle_dbapiunicode_cextensions 1154 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 1185 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_postgresql_psycopg2_dbapiunicode_cextensions 1155 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 1186 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1034 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1065 +test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1009 +test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1036 +test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1044 +test.aaa_profiling.test_orm.MergeTest.test_merge_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1075 # TEST: test.aaa_profiling.test_orm.MergeTest.test_merge_no_load -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_mssql_pyodbc_dbapiunicode_cextensions 93,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_mssql_pyodbc_dbapiunicode_nocextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_mysql_pymysql_dbapiunicode_nocextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_oracle_cx_oracle_dbapiunicode_cextensions 93,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_postgresql_psycopg2_dbapiunicode_cextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 99,19 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mssql_pyodbc_dbapiunicode_cextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mssql_pyodbc_dbapiunicode_nocextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mysql_mysqldb_dbapiunicode_cextensions 97,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mysql_mysqldb_dbapiunicode_nocextensions 97,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mysql_pymysql_dbapiunicode_cextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_mysql_pymysql_dbapiunicode_nocextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_oracle_cx_oracle_dbapiunicode_cextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_postgresql_psycopg2_dbapiunicode_cextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 103,20 -test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 103,20 +test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_sqlite_pysqlite_dbapiunicode_cextensions 101,17 +test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 101,17 +test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_sqlite_pysqlite_dbapiunicode_cextensions 105,18 +test.aaa_profiling.test_orm.MergeTest.test_merge_no_load 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 105,18 # TEST: test.aaa_profiling.test_orm.QueryTest.test_query_cols -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_mssql_pyodbc_dbapiunicode_nocextensions 6677 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_mysql_pymysql_dbapiunicode_nocextensions 16916 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 8087 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_postgresql_psycopg2_dbapiunicode_cextensions 5827 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6507 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 5771 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6451 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_mssql_pyodbc_dbapiunicode_cextensions 6310 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6890 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_mysql_pymysql_dbapiunicode_cextensions 13929 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_mysql_pymysql_dbapiunicode_nocextensions 14599 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_oracle_cx_oracle_dbapiunicode_cextensions 6310 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6980 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_postgresql_psycopg2_dbapiunicode_cextensions 6230 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6900 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 6092 -test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6762 +test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_cextensions 5764 +test.aaa_profiling.test_orm.QueryTest.test_query_cols 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6414 +test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_cextensions 5962 +test.aaa_profiling.test_orm.QueryTest.test_query_cols 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6632 # TEST: test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_mssql_pyodbc_dbapiunicode_cextensions 168601 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_mssql_pyodbc_dbapiunicode_nocextensions 178063 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_mysql_pymysql_dbapiunicode_nocextensions 327425 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_oracle_cx_oracle_dbapiunicode_cextensions 188198 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 193545 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_postgresql_psycopg2_dbapiunicode_cextensions 175705 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 176705 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 171413 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 172313 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mssql_pyodbc_dbapiunicode_cextensions 175530 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mssql_pyodbc_dbapiunicode_nocextensions 182638 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mysql_mysqldb_dbapiunicode_cextensions 183039 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mysql_mysqldb_dbapiunicode_nocextensions 187847 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mysql_pymysql_dbapiunicode_cextensions 291992 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_mysql_pymysql_dbapiunicode_nocextensions 299300 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_oracle_cx_oracle_dbapiunicode_cextensions 190812 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 198120 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_postgresql_psycopg2_dbapiunicode_cextensions 176372 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 183680 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 171480 -test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 178788 +test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_cextensions 166153 +test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 172857 +test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_cextensions 171502 +test.aaa_profiling.test_orm.SelectInEagerLoadTest.test_round_trip_results 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 178710 # TEST: test.aaa_profiling.test_orm.SessionTest.test_expire_lots -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_mssql_pyodbc_dbapiunicode_cextensions 1141 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_mssql_pyodbc_dbapiunicode_nocextensions 1125 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_mysql_pymysql_dbapiunicode_nocextensions 1146 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_oracle_cx_oracle_dbapiunicode_cextensions 1156 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 1164 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_postgresql_psycopg2_dbapiunicode_cextensions 1142 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 1142 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1146 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1139 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mssql_pyodbc_dbapiunicode_cextensions 1232 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mssql_pyodbc_dbapiunicode_nocextensions 1260 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mysql_mysqldb_dbapiunicode_cextensions 1256 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mysql_mysqldb_dbapiunicode_nocextensions 1258 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mysql_pymysql_dbapiunicode_cextensions 1241 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_mysql_pymysql_dbapiunicode_nocextensions 1263 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_oracle_cx_oracle_dbapiunicode_cextensions 1287 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 1265 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_postgresql_psycopg2_dbapiunicode_cextensions 1271 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 1274 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1261 -test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1254 +test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_cextensions 1153 +test.aaa_profiling.test_orm.SessionTest.test_expire_lots 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 1130 +test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_cextensions 1271 +test.aaa_profiling.test_orm.SessionTest.test_expire_lots 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 1264 # TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_mssql_pyodbc_dbapiunicode_cextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_mssql_pyodbc_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_mysql_mysqldb_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_mysql_pymysql_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_oracle_cx_oracle_dbapiunicode_cextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_postgresql_psycopg2_dbapiunicode_cextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_sqlite_pysqlite_dbapiunicode_cextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 103 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mssql_pyodbc_dbapiunicode_cextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mssql_pyodbc_dbapiunicode_nocextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mysql_mysqldb_dbapiunicode_cextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mysql_mysqldb_dbapiunicode_nocextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mysql_pymysql_dbapiunicode_cextensions 82 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_mysql_pymysql_dbapiunicode_nocextensions 82 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_oracle_cx_oracle_dbapiunicode_cextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_postgresql_psycopg2_dbapiunicode_cextensions 82 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 82 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_sqlite_pysqlite_dbapiunicode_cextensions 86 -test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 86 +test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_sqlite_pysqlite_dbapiunicode_cextensions 101 +test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 101 +test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_sqlite_pysqlite_dbapiunicode_cextensions 84 +test.aaa_profiling.test_pool.QueuePoolTest.test_first_connect 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 84 # TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_mssql_pyodbc_dbapiunicode_cextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_mssql_pyodbc_dbapiunicode_nocextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_mysql_pymysql_dbapiunicode_nocextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_oracle_cx_oracle_dbapiunicode_cextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_postgresql_psycopg2_dbapiunicode_cextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 33 test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_sqlite_pysqlite_dbapiunicode_cextensions 33 test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 33 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mssql_pyodbc_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mssql_pyodbc_dbapiunicode_nocextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mysql_mysqldb_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mysql_mysqldb_dbapiunicode_nocextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mysql_pymysql_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_mysql_pymysql_dbapiunicode_nocextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_oracle_cx_oracle_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_postgresql_psycopg2_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_sqlite_pysqlite_dbapiunicode_cextensions 25 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 25 - -# TEST: test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect - -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_mssql_pyodbc_dbapiunicode_cextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_mssql_pyodbc_dbapiunicode_nocextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_oracle_cx_oracle_dbapiunicode_cextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_postgresql_psycopg2_dbapiunicode_cextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_sqlite_pysqlite_dbapiunicode_cextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 8 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_mysql_mysqldb_dbapiunicode_cextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_mysql_mysqldb_dbapiunicode_nocextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_oracle_cx_oracle_dbapiunicode_cextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_postgresql_psycopg2_dbapiunicode_cextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_sqlite_pysqlite_dbapiunicode_cextensions 9 -test.aaa_profiling.test_pool.QueuePoolTest.test_second_samethread_connect 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 9 +test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_sqlite_pysqlite_dbapiunicode_cextensions 24 +test.aaa_profiling.test_pool.QueuePoolTest.test_second_connect 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 24 # TEST: test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute @@ -858,9 +389,9 @@ test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 52 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 47 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 52 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 50 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 48 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 52 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 50 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 48 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 52 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 52 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_connection_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 56 @@ -883,10 +414,10 @@ test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_ test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_mysql_pymysql_dbapiunicode_nocextensions 92 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_cextensions 86 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 92 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 90 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_cextensions 86 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 92 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 90 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 92 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_cextensions 86 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 90 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_cextensions 90 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mssql_pyodbc_dbapiunicode_nocextensions 94 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_mysql_mysqldb_dbapiunicode_cextensions 90 @@ -897,8 +428,8 @@ test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_ test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 94 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_cextensions 90 test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 94 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 90 -test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 94 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_cextensions 88 +test.aaa_profiling.test_resultset.ExecutionTest.test_minimal_engine_execute 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 92 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile @@ -933,10 +464,10 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysq test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128259 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 375 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36419 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 273 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 277 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6293 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 248 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6270 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 246 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6268 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 245 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6249 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 281 @@ -947,8 +478,8 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_or test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6338 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 269 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6273 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 242 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6246 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 240 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6244 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode @@ -958,10 +489,10 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymys test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128259 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 375 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36419 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 273 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 277 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6293 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 248 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6270 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 246 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6268 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 245 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6249 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 281 @@ -972,8 +503,8 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_o test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6338 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 269 test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6273 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 242 -test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6246 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 240 +test.aaa_profiling.test_resultset.ResultSetTest.test_raw_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6244 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_string @@ -983,10 +514,10 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_db test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_pymysql_dbapiunicode_nocextensions 128488 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_cextensions 555 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36569 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 491 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_cextensions 500 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6491 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 452 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6454 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_cextensions 455 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6457 test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_cextensions 519 test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6523 test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_mysql_mysqldb_dbapiunicode_cextensions 523 @@ -997,8 +528,8 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6542 test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_cextensions 511 test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6515 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 469 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6473 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_cextensions 472 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6476 # TEST: test.aaa_profiling.test_resultset.ResultSetTest.test_unicode @@ -1008,10 +539,10 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_d test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_pymysql_dbapiunicode_nocextensions 128488 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_cextensions 555 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_oracle_cx_oracle_dbapiunicode_nocextensions 36569 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 491 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_cextensions 500 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_dbapiunicode_nocextensions 6491 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 452 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6454 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_cextensions 455 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_sqlite_pysqlite_dbapiunicode_nocextensions 6457 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_cextensions 519 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mssql_pyodbc_dbapiunicode_nocextensions 6523 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_mysql_mysqldb_dbapiunicode_cextensions 523 @@ -1022,15 +553,17 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracl test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_oracle_cx_oracle_dbapiunicode_nocextensions 6542 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_cextensions 511 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6515 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 469 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6473 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_cextensions 472 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 3.7_sqlite_pysqlite_dbapiunicode_nocextensions 6476 # TEST: test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation +test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6465,325,4295,12719,1286,2222,2793 test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 6177,306,4162,12597,1233,2133,2852 test.aaa_profiling.test_zoomark.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 6260,306,4242,13203,1344,2151,3046 # TEST: test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation +test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 2.7_postgresql_psycopg2_dbapiunicode_cextensions 6959,432,7231,18822,1299,2861 test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_cextensions 7090,411,7281,19190,1247,2897 test.aaa_profiling.test_zoomark_orm.ZooMarkTest.test_invocation 3.7_postgresql_psycopg2_dbapiunicode_nocextensions 7186,416,7465,20675,1350,2957 diff --git a/test/requirements.py b/test/requirements.py index 47a84fc89..53c1f72e4 100644 --- a/test/requirements.py +++ b/test/requirements.py @@ -1451,6 +1451,12 @@ class DefaultRequirements(SuiteRequirements): or config.db.dialect._mariadb_normalized_version_info < (10, 3) ) + def _mysql_not_mariadb_104(self, config): + return against(config, "mysql") and ( + not config.db.dialect._is_mariadb + or config.db.dialect._mariadb_normalized_version_info < (10, 4) + ) + def _has_mysql_on_windows(self, config): return ( against(config, "mysql") @@ -1487,3 +1493,7 @@ class DefaultRequirements(SuiteRequirements): @property def computed_columns(self): return skip_if(["postgresql < 12", "sqlite", "mysql < 5.7"]) + + @property + def python_profiling_backend(self): + return only_on(["sqlite"]) diff --git a/test/sql/test_query.py b/test/sql/test_query.py index ce57260b7..aa5e913d5 100644 --- a/test/sql/test_query.py +++ b/test/sql/test_query.py @@ -1208,7 +1208,9 @@ class CompoundTest(fixtures.TestBase): "firebird", "has trouble extracting anonymous column from union subquery", ) - @testing.fails_on("mysql", "FIXME: unknown") + @testing.fails_on( + testing.requires._mysql_not_mariadb_104, "FIXME: unknown" + ) @testing.fails_on("sqlite", "FIXME: unknown") def test_union_all(self): e = union_all( @@ -1312,7 +1314,8 @@ class CompoundTest(fixtures.TestBase): eq_(found2, wanted) @testing.fails_on( - ["sqlite", "mysql"], "Can't handle this style of nesting" + ["sqlite", testing.requires._mysql_not_mariadb_104], + "Can't handle this style of nesting", ) @testing.requires.except_ def test_except_style3(self): @@ -1345,7 +1348,8 @@ class CompoundTest(fixtures.TestBase): @testing.requires.intersect @testing.fails_on( - ["sqlite", "mysql"], "sqlite can't handle leading parenthesis" + ["sqlite", testing.requires._mysql_not_mariadb_104], + "sqlite can't handle leading parenthesis", ) def test_intersect_unions(self): u = intersect( |