From 6930dfc032c3f9f474e71ab4e021c0ef8384930e Mon Sep 17 00:00:00 2001 From: Mike Bayer Date: Mon, 27 Apr 2020 12:58:12 -0400 Subject: Convert execution to move through Session This patch replaces the ORM execution flow with a single pathway through Session.execute() for all queries, including Core and ORM. Currently included is full support for ORM Query, Query.from_statement(), select(), as well as the baked query and horizontal shard systems. Initial changes have also been made to the dogpile caching example, which like baked query makes use of a new ORM-specific execution hook that replaces the use of both QueryEvents.before_compile() as well as Query._execute_and_instances() as the central ORM interception hooks. select() and Query() constructs alike can be passed to Session.execute() where they will return ORM results in a Results object. This API is currently used internally by Query. Full support for Session.execute()->results to behave in a fully 2.0 fashion will be in later changesets. bulk update/delete with ORM support will also be delivered via the update() and delete() constructs, however these have not yet been adapted to the new system and may follow in a subsequent update. Performance is also beginning to lag as of this commit and some previous ones. It is hoped that a few central functions such as the coercions functions can be rewritten in C to re-gain performance. Additionally, query caching is now available and some subsequent patches will attempt to cache more of the per-execution work from the ORM layer, e.g. column getters and adapters. This patch also contains initial "turn on" of the caching system enginewide via the query_cache_size parameter to create_engine(). Still defaulting at zero for "no caching". The caching system still needs adjustments in order to gain adequate performance. Change-Id: I047a7ebb26aa85dc01f6789fac2bff561dcd555d --- test/sql/test_resultset.py | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) (limited to 'test/sql/test_resultset.py') diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py index 6c83697dc..0eff94635 100644 --- a/test/sql/test_resultset.py +++ b/test/sql/test_resultset.py @@ -1856,7 +1856,34 @@ class KeyTargetingTest(fixtures.TablesTest): is_( existing_metadata._keymap[k], adapted_metadata._keymap[other_k] ) - return stmt1, existing_metadata, stmt2, adapted_metadata + + @testing.combinations( + _adapt_result_columns_fixture_one, + _adapt_result_columns_fixture_two, + _adapt_result_columns_fixture_three, + _adapt_result_columns_fixture_four, + argnames="stmt_fn", + ) + def test_adapt_result_columns_from_cache(self, connection, stmt_fn): + stmt1 = stmt_fn(self) + stmt2 = stmt_fn(self) + + cache = {} + result = connection._execute_20( + stmt1, + execution_options={"compiled_cache": cache, "future_result": True}, + ) + result.close() + assert cache + + result = connection._execute_20( + stmt2, + execution_options={"compiled_cache": cache, "future_result": True}, + ) + + row = result.first() + for col in stmt2.selected_columns: + assert col in row._mapping class PositionalTextTest(fixtures.TablesTest): -- cgit v1.2.1