From: Mike Bayer Date: Fri, 23 Nov 2012 04:45:24 +0000 (-0500) Subject: - recognize that do_rollback() and do_commit() work with a DBAPI connection, X-Git-Tag: rel_0_8_0b2~28 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=0f0ce7c9b7c4b3a9f1329dfa9c42d0d69386d48f;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git - recognize that do_rollback() and do_commit() work with a DBAPI connection, whereas the other do_rollback_twophase(), savepoint etc. work with :class:`.Connection`. the context on these are different as twophase/savepoint are available at the :class:`.Connection` level, whereas commit/rollback are needed at a lower level as well. Rename the argument to "dbapi_connection" when the conneciton is in fact the DBAPI interface. - start thinking about being able to track "autocommit" vs. "commit", but not sure we have a need for this yet. - have Pool call out to a Dialect for all rollback/commit/close operations now. Pool no longer calls DBAPI methods directly. May use this for a workaround for [ticket:2611] - add a new Pool event reset() to allow the pool's reset of the connection to be intercepted. - remove methods in Informix dialect which appear to be hardcoding some isolation settings on new Transaction only; the isolation API should be implemented for Informix. also removed "flag" for transaction commit/rollback being not available; this should be based on server/DBAPI version and we will need someone with test access in order to help determine how this should work --- diff --git a/doc/build/changelog/changelog_08.rst b/doc/build/changelog/changelog_08.rst index 15206134e0..8046a88920 100644 --- a/doc/build/changelog/changelog_08.rst +++ b/doc/build/changelog/changelog_08.rst @@ -114,6 +114,46 @@ Support for reflection of the "name" of primary key constraints added, courtesy Dave Moore. + .. change:: + :tags: informix + + Some cruft regarding informix transaction handling has been + removed, including a feature that would skip calling + commit()/rollback() as well as some hardcoded isolation level + assumptions on begin().. The status of this dialect is not + well understood as we don't have any users working with it, + nor any access to an Informix database. If someone with + access to Informix wants to help test this dialect, please + let us know. + + .. change:: + :tags: pool, feature + + The :class:`.Pool` will now log all connection.close() + operations equally, including closes which occur for + invalidated connections, detached connections, and connections + beyond the pool capacity. + + .. change:: + :tags: pool, feature + :tickets: 2611 + + The :class:`.Pool` now consults the :class:`.Dialect` for + functionality regarding how the connection should be + "auto rolled back", as well as closed. This grants more + control of transaction scope to the dialect, so that we + will be better able to implement transactional workarounds + like those potentially needed for pysqlite and cx_oracle. + + .. change:: + :tags: pool, feature + + Added new :meth:`.PoolEvents.reset` hook to capture + the event before a connection is auto-rolled back, upon + return to the pool. Together with + :meth:`.ConnectionEvents.rollback` this allows all rollback + events to be intercepted. + .. changelog:: :version: 0.8.0b1 :released: October 30, 2012 diff --git a/lib/sqlalchemy/dialects/drizzle/base.py b/lib/sqlalchemy/dialects/drizzle/base.py index 2b5df38601..0f1e13fd85 100644 --- a/lib/sqlalchemy/dialects/drizzle/base.py +++ b/lib/sqlalchemy/dialects/drizzle/base.py @@ -446,16 +446,6 @@ class DrizzleDialect(mysql_dialect.MySQLDialect): conn.autocommit(False) return connect - def do_commit(self, connection): - """Execute a COMMIT.""" - - connection.commit() - - def do_rollback(self, connection): - """Execute a ROLLBACK.""" - - connection.rollback() - @reflection.cache def get_table_names(self, connection, schema=None, **kw): """Return a Unicode SHOW TABLES from a given schema.""" diff --git a/lib/sqlalchemy/dialects/firebird/base.py b/lib/sqlalchemy/dialects/firebird/base.py index 9a8e8044a7..4e181c63b7 100644 --- a/lib/sqlalchemy/dialects/firebird/base.py +++ b/lib/sqlalchemy/dialects/firebird/base.py @@ -723,10 +723,10 @@ class FBDialect(default.DefaultDialect): # when there are no arguments. cursor.execute(statement, parameters or []) - def do_rollback(self, connection): + def do_rollback(self, dbapi_connection): # Use the retaining feature, that keeps the transaction going - connection.rollback(True) + dbapi_connection.rollback(True) - def do_commit(self, connection): + def do_commit(self, dbapi_connection): # Use the retaining feature, that keeps the transaction going - connection.commit(True) + dbapi_connection.commit(True) diff --git a/lib/sqlalchemy/dialects/informix/base.py b/lib/sqlalchemy/dialects/informix/base.py index c3fbccb114..05efa9321a 100644 --- a/lib/sqlalchemy/dialects/informix/base.py +++ b/lib/sqlalchemy/dialects/informix/base.py @@ -362,10 +362,6 @@ class InformixDialect(default.DefaultDialect): preparer = InformixIdentifierPreparer default_paramstyle = 'qmark' - def __init__(self, has_transactions=True, *args, **kwargs): - self.has_transactions = has_transactions - default.DefaultDialect.__init__(self, *args, **kwargs) - def initialize(self, connection): super(InformixDialect, self).initialize(connection) @@ -375,20 +371,6 @@ class InformixDialect(default.DefaultDialect): else: self.max_identifier_length = 128 - def do_begin(self, connection): - cu = connection.cursor() - cu.execute('SET LOCK MODE TO WAIT') - if self.has_transactions: - cu.execute('SET ISOLATION TO REPEATABLE READ') - - def do_commit(self, connection): - if self.has_transactions: - connection.commit() - - def do_rollback(self, connection): - if self.has_transactions: - connection.rollback() - def _get_table_names(self, connection, schema, type, **kw): schema = schema or self.default_schema_name s = "select tabname, owner from systables where owner=? and tabtype=?" diff --git a/lib/sqlalchemy/dialects/mysql/base.py b/lib/sqlalchemy/dialects/mysql/base.py index dc2ae7515c..2cda1a1474 100644 --- a/lib/sqlalchemy/dialects/mysql/base.py +++ b/lib/sqlalchemy/dialects/mysql/base.py @@ -1933,7 +1933,7 @@ class MySQLDialect(default.DefaultDialect): cursor.close() return val.upper().replace("-", " ") - def do_commit(self, connection): + def do_commit(self, dbapi_connection): """Execute a COMMIT.""" # COMMIT/ROLLBACK were introduced in 3.23.15. @@ -1942,7 +1942,7 @@ class MySQLDialect(default.DefaultDialect): # Ignore commit/rollback if support isn't present, otherwise even basic # operations via autocommit fail. try: - connection.commit() + dbapi_connection.commit() except: if self.server_version_info < (3, 23, 15): args = sys.exc_info()[1].args @@ -1950,11 +1950,11 @@ class MySQLDialect(default.DefaultDialect): return raise - def do_rollback(self, connection): + def do_rollback(self, dbapi_connection): """Execute a ROLLBACK.""" try: - connection.rollback() + dbapi_connection.rollback() except: if self.server_version_info < (3, 23, 15): args = sys.exc_info()[1].args diff --git a/lib/sqlalchemy/engine/base.py b/lib/sqlalchemy/engine/base.py index a3a1bcfc2e..626fee8c68 100644 --- a/lib/sqlalchemy/engine/base.py +++ b/lib/sqlalchemy/engine/base.py @@ -479,7 +479,7 @@ class Connection(Connectable): else: self.__transaction = None - def _commit_impl(self): + def _commit_impl(self, autocommit=False): if self._has_events: self.dispatch.commit(self) @@ -910,7 +910,7 @@ class Connection(Connectable): result.close(_autoclose_connection=False) if self.__transaction is None and context.should_autocommit: - self._commit_impl() + self._commit_impl(autocommit=True) if result.closed and self.should_close_with_result: self.close() @@ -1320,6 +1320,7 @@ class Engine(Connectable, log.Identified): self.pool = pool self.url = url self.dialect = dialect + self.pool._dialect = dialect if logging_name: self.logging_name = logging_name self.echo = echo diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py index 335515a7b3..e0068dde14 100644 --- a/lib/sqlalchemy/engine/default.py +++ b/lib/sqlalchemy/engine/default.py @@ -282,26 +282,17 @@ class DefaultDialect(interfaces.Dialect): opts.update(url.query) return [[], opts] - def do_begin(self, connection): - """Implementations might want to put logic here for turning - autocommit on/off, etc. - """ - + def do_begin(self, dbapi_connection): pass - def do_rollback(self, connection): - """Implementations might want to put logic here for turning - autocommit on/off, etc. - """ + def do_rollback(self, dbapi_connection): + dbapi_connection.rollback() - connection.rollback() - - def do_commit(self, connection): - """Implementations might want to put logic here for turning - autocommit on/off, etc. - """ + def do_commit(self, dbapi_connection): + dbapi_connection.commit() - connection.commit() + def do_close(self, dbapi_connection): + dbapi_connection.close() def create_xid(self): """Create a random two-phase transaction ID. diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py index 66856a00ec..0adec7fd36 100644 --- a/lib/sqlalchemy/engine/interfaces.py +++ b/lib/sqlalchemy/engine/interfaces.py @@ -402,15 +402,63 @@ class Dialect(object): raise NotImplementedError() - def do_begin(self, connection): - """Provide an implementation of *connection.begin()*, given a - DB-API connection.""" + def do_begin(self, dbapi_connection): + """Provide an implementation of ``connection.begin()``, given a + DB-API connection. + + The DBAPI has no dedicated "begin" method and it is expected + that transactions are implicit. This hook is provided for those + DBAPIs that might need additional help in this area. + + Note that :meth:`.Dialect.do_begin` is not called unless a + :class:`.Transaction` object is in use. The + :meth:`.Dialect.do_autocommit` + hook is provided for DBAPIs that need some extra commands emitted + after a commit in order to enter the next transaction, when the + SQLAlchemy :class:`.Connection` is used in it's default "autocommit" + mode. + + :param dbapi_connection: a DBAPI connection, typically + proxied within a :class:`.ConnectionFairy`. + + """ raise NotImplementedError() - def do_rollback(self, connection): - """Provide an implementation of *connection.rollback()*, given - a DB-API connection.""" + def do_rollback(self, dbapi_connection): + """Provide an implementation of ``connection.rollback()``, given + a DB-API connection. + + :param dbapi_connection: a DBAPI connection, typically + proxied within a :class:`.ConnectionFairy`. + + """ + + raise NotImplementedError() + + + def do_commit(self, dbapi_connection): + """Provide an implementation of ``connection.commit()``, given a + DB-API connection. + + :param dbapi_connection: a DBAPI connection, typically + proxied within a :class:`.ConnectionFairy`. + + """ + + raise NotImplementedError() + + def do_close(self, dbapi_connection): + """Provide an implementation of ``connection.close()``, given a DBAPI + connection. + + This hook is called by the :class:`.Pool` when a connection has been + detached from the pool, or is being returned beyond the normal + capacity of the pool. + + .. versionadded:: 0.8 + + """ raise NotImplementedError() @@ -424,53 +472,91 @@ class Dialect(object): raise NotImplementedError() - def do_commit(self, connection): - """Provide an implementation of *connection.commit()*, given a - DB-API connection.""" + def do_savepoint(self, connection, name): + """Create a savepoint with the given name. - raise NotImplementedError() + :param connection: a :class:`.Connection`. + :param name: savepoint name. - def do_savepoint(self, connection, name): - """Create a savepoint with the given name on a SQLAlchemy - connection.""" + """ raise NotImplementedError() def do_rollback_to_savepoint(self, connection, name): - """Rollback a SQL Alchemy connection to the named savepoint.""" + """Rollback a connection to the named savepoint. + + :param connection: a :class:`.Connection`. + :param name: savepoint name. + + """ raise NotImplementedError() def do_release_savepoint(self, connection, name): - """Release the named savepoint on a SQL Alchemy connection.""" + """Release the named savepoint on a connection. + + :param connection: a :class:`.Connection`. + :param name: savepoint name. + """ raise NotImplementedError() def do_begin_twophase(self, connection, xid): - """Begin a two phase transaction on the given connection.""" + """Begin a two phase transaction on the given connection. + + :param connection: a :class:`.Connection`. + :param xid: xid + + """ raise NotImplementedError() def do_prepare_twophase(self, connection, xid): - """Prepare a two phase transaction on the given connection.""" + """Prepare a two phase transaction on the given connection. + + :param connection: a :class:`.Connection`. + :param xid: xid + + """ raise NotImplementedError() def do_rollback_twophase(self, connection, xid, is_prepared=True, recover=False): - """Rollback a two phase transaction on the given connection.""" + """Rollback a two phase transaction on the given connection. + + :param connection: a :class:`.Connection`. + :param xid: xid + :param is_prepared: whether or not + :meth:`.TwoPhaseTransaction.prepare` was called. + :param recover: if the recover flag was passed. + + """ raise NotImplementedError() def do_commit_twophase(self, connection, xid, is_prepared=True, recover=False): - """Commit a two phase transaction on the given connection.""" + """Commit a two phase transaction on the given connection. + + + :param connection: a :class:`.Connection`. + :param xid: xid + :param is_prepared: whether or not + :meth:`.TwoPhaseTransaction.prepare` was called. + :param recover: if the recover flag was passed. + + """ raise NotImplementedError() def do_recover_twophase(self, connection): """Recover list of uncommited prepared two phase transaction - identifiers on the given connection.""" + identifiers on the given connection. + + :param connection: a :class:`.Connection`. + + """ raise NotImplementedError() diff --git a/lib/sqlalchemy/events.py b/lib/sqlalchemy/events.py index 07661c9192..5d26657790 100644 --- a/lib/sqlalchemy/events.py +++ b/lib/sqlalchemy/events.py @@ -336,6 +336,37 @@ class PoolEvents(event.Events): """ + def reset(self, dbapi_con, con_record): + """Called before the "reset" action occurs for a pooled connection. + + This event represents + when the ``rollback()`` method is called on the DBAPI connection + before it is returned to the pool. The behavior of "reset" can + be controlled, including disabled, using the ``reset_on_return`` + pool argument. + + + The :meth:`.PoolEvents.reset` event is usually followed by the + the :meth:`.PoolEvents.checkin` event is called, except in those + cases where the connection is discarded immediately after reset. + + :param dbapi_con: + A raw DB-API connection + + :param con_record: + The ``_ConnectionRecord`` that persistently manages the connection + + .. versionadded:: 0.8 + + .. seealso:: + + :meth:`.ConnectionEvents.rollback` + + :meth:`.ConnectionEvents.commit` + + """ + + class ConnectionEvents(event.Events): """Available events for :class:`.Connectable`, which includes @@ -592,14 +623,31 @@ class ConnectionEvents(event.Events): """ def rollback(self, conn): - """Intercept rollback() events. + """Intercept rollback() events, as initiated by a + :class:`.Transaction`. + + Note that the :class:`.Pool` also "auto-rolls back" + a DBAPI connection upon checkin, if the ``reset_on_return`` + flag is set to its default value of ``'rollback'``. + To intercept this + rollback, use the :meth:`.PoolEvents.reset` hook. :param conn: :class:`.Connection` object + .. seealso:: + + :meth:`.PoolEvents.reset` + """ def commit(self, conn): - """Intercept commit() events. + """Intercept commit() events, as initiated by a + :class:`.Transaction`. + + Note that the :class:`.Pool` may also "auto-commit" + a DBAPI connection upon checkin, if the ``reset_on_return`` + flag is set to the value ``'commit'``. To intercept this + commit, use the :meth:`.PoolEvents.reset` hook. :param conn: :class:`.Connection` object """ diff --git a/lib/sqlalchemy/pool.py b/lib/sqlalchemy/pool.py index 5518b1e222..368cf9d6f0 100644 --- a/lib/sqlalchemy/pool.py +++ b/lib/sqlalchemy/pool.py @@ -65,10 +65,29 @@ reset_rollback = util.symbol('reset_rollback') reset_commit = util.symbol('reset_commit') reset_none = util.symbol('reset_none') +class _ConnDialect(object): + """partial implementation of :class:`.Dialect` + which provides DBAPI connection methods. + + When a :class:`.Pool` is combined with an :class:`.Engine`, + the :class:`.Engine` replaces this with its own + :class:`.Dialect`. + + """ + def do_rollback(self, dbapi_connection): + dbapi_connection.rollback() + + def do_commit(self, dbapi_connection): + dbapi_connection.commit() + + def do_close(self, dbapi_connection): + dbapi_connection.close() class Pool(log.Identified): """Abstract base class for connection pools.""" + _dialect = _ConnDialect() + def __init__(self, creator, recycle=-1, echo=None, use_threadlocal=False, @@ -76,7 +95,8 @@ class Pool(log.Identified): reset_on_return=True, listeners=None, events=None, - _dispatch=None): + _dispatch=None, + _dialect=None): """ Construct a Pool. @@ -152,6 +172,8 @@ class Pool(log.Identified): self.echo = echo if _dispatch: self.dispatch._update(_dispatch, only_propagate=False) + if _dialect: + self._dialect = _dialect if events: for fn, target in events: event.listen(self, target, fn) @@ -164,6 +186,16 @@ class Pool(log.Identified): dispatch = event.dispatcher(events.PoolEvents) + def _close_connection(self, connection): + self.logger.debug("Closing connection %r", connection) + try: + self._dialect.do_close(connection) + except (SystemExit, KeyboardInterrupt): + raise + except: + self.logger.debug("Exception closing connection %r", + connection) + @util.deprecated( 2.7, "Pool.add_listener is deprecated. Use event.listen()") def add_listener(self, listener): @@ -296,14 +328,7 @@ class _ConnectionRecord(object): def close(self): if self.connection is not None: - self.__pool.logger.debug("Closing connection %r", self.connection) - try: - self.connection.close() - except (SystemExit, KeyboardInterrupt): - raise - except: - self.__pool.logger.debug("Exception closing connection %r", - self.connection) + self.__pool._close_connection(self.connection) def invalidate(self, e=None): if e is not None: @@ -335,15 +360,7 @@ class _ConnectionRecord(object): return self.connection def __close(self): - try: - self.__pool.logger.debug("Closing connection %r", self.connection) - self.connection.close() - except (SystemExit, KeyboardInterrupt): - raise - except Exception, e: - self.__pool.logger.debug( - "Connection %r threw an error on close: %s", - self.connection, e) + self.__pool._close_connection(self.connection) def __connect(self): try: @@ -365,13 +382,15 @@ def _finalize_fairy(connection, connection_record, pool, ref, echo): if connection is not None: try: + if pool.dispatch.reset: + pool.dispatch.reset(connection, connection_record) if pool._reset_on_return is reset_rollback: - connection.rollback() + pool._dialect.do_rollback(connection) elif pool._reset_on_return is reset_commit: - connection.commit() + pool._dialect.do_commit(connection) # Immediately close detached instances if connection_record is None: - connection.close() + pool._close_connection(connection) except Exception, e: if connection_record is not None: connection_record.invalidate(e=e) @@ -556,7 +575,8 @@ class SingletonThreadPool(Pool): echo=self.echo, logging_name=self._orig_logging_name, use_threadlocal=self._use_threadlocal, - _dispatch=self.dispatch) + _dispatch=self.dispatch, + _dialect=self._dialect) def dispose(self): """Dispose of this pool.""" @@ -768,7 +788,8 @@ class QueuePool(Pool): recycle=self._recycle, echo=self.echo, logging_name=self._orig_logging_name, use_threadlocal=self._use_threadlocal, - _dispatch=self.dispatch) + _dispatch=self.dispatch, + _dialect=self._dialect) def dispose(self): while True: @@ -841,7 +862,8 @@ class NullPool(Pool): echo=self.echo, logging_name=self._orig_logging_name, use_threadlocal=self._use_threadlocal, - _dispatch=self.dispatch) + _dispatch=self.dispatch, + _dialect=self._dialect) def dispose(self): pass @@ -881,7 +903,8 @@ class StaticPool(Pool): reset_on_return=self._reset_on_return, echo=self.echo, logging_name=self._orig_logging_name, - _dispatch=self.dispatch) + _dispatch=self.dispatch, + _dialect=self._dialect) def _create_connection(self): return self._conn @@ -932,7 +955,8 @@ class AssertionPool(Pool): self.logger.info("Pool recreating") return self.__class__(self._creator, echo=self.echo, logging_name=self._orig_logging_name, - _dispatch=self.dispatch) + _dispatch=self.dispatch, + _dialect=self._dialect) def _do_get(self): if self._checked_out: diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py index d991cc7be7..c01d14c4f9 100644 --- a/test/engine/test_pool.py +++ b/test/engine/test_pool.py @@ -41,15 +41,16 @@ class PoolTestBase(fixtures.TestBase): @classmethod def teardown_class(cls): - pool.clear_managers() + pool.clear_managers() def _queuepool_fixture(self, **kw): - dbapi = MockDBAPI() - return pool.QueuePool(creator=lambda: dbapi.connect('foo.db'), **kw) + dbapi, pool = self._queuepool_dbapi_fixture(**kw) + return pool def _queuepool_dbapi_fixture(self, **kw): dbapi = MockDBAPI() - return dbapi, pool.QueuePool(creator=lambda: dbapi.connect('foo.db'), **kw) + return dbapi, pool.QueuePool(creator=lambda: dbapi.connect('foo.db'), + **kw) class PoolTest(PoolTestBase): def test_manager(self): @@ -83,6 +84,9 @@ class PoolTest(PoolTestBase): assert c1 is not c2 assert c1 is c3 + + + def test_bad_args(self): manager = pool.manage(MockDBAPI()) connection = manager.connect(None) @@ -106,6 +110,7 @@ class PoolTest(PoolTestBase): for row in cursor: eq_(row, expected.pop(0)) + def test_no_connect_on_recreate(self): def creator(): raise Exception("no creates allowed") @@ -210,8 +215,54 @@ class PoolTest(PoolTestBase): self.assert_('foo2' in c.info) +class PoolDialectTest(PoolTestBase): + def _dialect(self): + canary = [] + class PoolDialect(object): + def do_rollback(self, dbapi_connection): + canary.append('R') + dbapi_connection.rollback() + + def do_commit(self, dbapi_connection): + canary.append('C') + dbapi_connection.commit() + + def do_close(self, dbapi_connection): + canary.append('CL') + dbapi_connection.close() + return PoolDialect(), canary + + def _do_test(self, pool_cls, assertion): + mock_dbapi = MockDBAPI() + dialect, canary = self._dialect() + + p = pool_cls(creator=mock_dbapi.connect) + p._dialect = dialect + conn = p.connect() + conn.close() + p.dispose() + p.recreate() + conn = p.connect() + conn.close() + eq_(canary, assertion) + + def test_queue_pool(self): + self._do_test(pool.QueuePool, ['R', 'CL', 'R']) + + def test_assertion_pool(self): + self._do_test(pool.AssertionPool, ['R', 'CL', 'R']) + + def test_singleton_pool(self): + self._do_test(pool.SingletonThreadPool, ['R', 'CL', 'R']) + + def test_null_pool(self): + self._do_test(pool.NullPool, ['R', 'CL', 'R', 'CL']) -class PoolEventsTest(object): #PoolTestBase): + def test_static_pool(self): + self._do_test(pool.StaticPool, ['R', 'R']) + + +class PoolEventsTest(PoolTestBase): def _first_connect_event_fixture(self): p = self._queuepool_fixture() canary = [] @@ -249,6 +300,15 @@ class PoolEventsTest(object): #PoolTestBase): return p, canary + def _reset_event_fixture(self): + p = self._queuepool_fixture() + canary = [] + def reset(*arg, **kw): + canary.append('reset') + event.listen(p, 'reset', reset) + + return p, canary + def test_first_connect_event(self): p, canary = self._first_connect_event_fixture() @@ -344,6 +404,14 @@ class PoolEventsTest(object): #PoolTestBase): c1.close() eq_(canary, ['checkin']) + def test_reset_event(self): + p, canary = self._reset_event_fixture() + + c1 = p.connect() + eq_(canary, []) + c1.close() + eq_(canary, ['reset']) + def test_checkin_event_gc(self): p, canary = self._checkin_event_fixture() diff --git a/test/profiles.txt b/test/profiles.txt index bd0eb156c0..8feee321de 100644 --- a/test/profiles.txt +++ b/test/profiles.txt @@ -7,8 +7,8 @@ # 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 option - -# this file will be rewritten including the new 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 @@ -94,7 +94,7 @@ test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.5_sqlite_pysqlite_nocext test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.6_sqlite_pysqlite_nocextensions 1174 test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_mysql_mysqldb_cextensions 1341 test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_mysql_mysqldb_nocextensions 1366 -test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_postgresql_psycopg2_cextensions 1200 +test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_postgresql_psycopg2_cextensions 1275 test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_postgresql_psycopg2_nocextensions 1225 test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_cextensions 1149 test.aaa_profiling.test_orm.MergeTest.test_merge_load 2.7_sqlite_pysqlite_nocextensions 1174 @@ -180,7 +180,7 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_contains_doesnt_compile 2.7 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.5_sqlite_pysqlite_nocextensions 14413 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.6_sqlite_pysqlite_nocextensions 14414 -test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_mysqldb_cextensions 452 +test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_mysqldb_cextensions 476 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_mysql_mysqldb_nocextensions 14472 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_cextensions 20438 test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_postgresql_psycopg2_nocextensions 34458 @@ -191,7 +191,7 @@ test.aaa_profiling.test_resultset.ResultSetTest.test_string 2.7_sqlite_pysqlite_ test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.5_sqlite_pysqlite_nocextensions 14413 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.6_sqlite_pysqlite_nocextensions 14414 -test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_mysqldb_cextensions 452 +test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_mysqldb_cextensions 476 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_mysql_mysqldb_nocextensions 44472 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_cextensions 20438 test.aaa_profiling.test_resultset.ResultSetTest.test_unicode 2.7_postgresql_psycopg2_nocextensions 34458