From: Mike Bayer Date: Mon, 16 Nov 2020 15:15:17 +0000 (-0500) Subject: Ensure the "orm" plugin is used unconditionally for bundles X-Git-Tag: rel_1_4_0b2~150 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=218fc83f3997dc0c152278eea0740b088074784b;p=thirdparty%2Fsqlalchemy%2Fsqlalchemy.git Ensure the "orm" plugin is used unconditionally for bundles This also introduces that the "orm" plugin may be used when the plugin_subject is None. Fixed regression where the :paramref:`.Bundle.single_entity` flag would take effect for a :class:`.Bundle` even though it were not set. Additionally, this flag is legacy as it only makes sense for the :class:`_orm.Query` object and not 2.0 style execution. a deprecation warning is emitted when used with new-style execution. Fixes: #5702 Change-Id: If9f43365b9d966cb398890aeba2efa555658a7e5 --- diff --git a/doc/build/changelog/unreleased_14/5702.rst b/doc/build/changelog/unreleased_14/5702.rst new file mode 100644 index 0000000000..e0a956108f --- /dev/null +++ b/doc/build/changelog/unreleased_14/5702.rst @@ -0,0 +1,9 @@ +.. change:: + :tags: bug, orm + :tickets: 5702 + + Fixed regression where the :paramref:`.Bundle.single_entity` flag would + take effect for a :class:`.Bundle` even though it were not set. + Additionally, this flag is legacy as it only makes sense for the + :class:`_orm.Query` object and not 2.0 style execution. a deprecation + warning is emitted when used with new-style execution. diff --git a/lib/sqlalchemy/orm/context.py b/lib/sqlalchemy/orm/context.py index 12759f018c..cd654ed3d6 100644 --- a/lib/sqlalchemy/orm/context.py +++ b/lib/sqlalchemy/orm/context.py @@ -242,7 +242,8 @@ class ORMCompileState(CompileState): except KeyError: assert False, "statement had 'orm' plugin but no plugin_subject" else: - bind_arguments["mapper"] = plugin_subject.mapper + if plugin_subject: + bind_arguments["mapper"] = plugin_subject.mapper if load_options._autoflush: session._autoflush() @@ -342,10 +343,10 @@ class ORMFromStatementCompileState(ORMCompileState): self._polymorphic_adapters = {} self._no_yield_pers = set() - _QueryEntity.to_compile_state(self, statement_container._raw_columns) - self.compile_options = statement_container._compile_options + _QueryEntity.to_compile_state(self, statement_container._raw_columns) + self.current_path = statement_container._compile_options._current_path if toplevel and statement_container._with_options: @@ -494,10 +495,10 @@ class ORMSelectCompileState(ORMCompileState, SelectState): ) self._setup_with_polymorphics() - _QueryEntity.to_compile_state(self, select_statement._raw_columns) - self.compile_options = select_statement._compile_options + _QueryEntity.to_compile_state(self, select_statement._raw_columns) + # determine label style. we can make different decisions here. # at the moment, trying to see if we can always use DISAMBIGUATE_ONLY # rather than LABEL_STYLE_NONE, and if we can use disambiguate style @@ -2365,6 +2366,14 @@ class _BundleEntity(_QueryEntity): ) self.supports_single_entity = self.bundle.single_entity + if ( + self.supports_single_entity + and not compile_state.compile_options._use_legacy_query_style + ): + util.warn_deprecated_20( + "The Bundle.single_entity flag has no effect when " + "using 2.0 style execution." + ) @property def mapper(self): diff --git a/lib/sqlalchemy/orm/strategies.py b/lib/sqlalchemy/orm/strategies.py index 1d47097266..7f7bab6825 100644 --- a/lib/sqlalchemy/orm/strategies.py +++ b/lib/sqlalchemy/orm/strategies.py @@ -2730,7 +2730,14 @@ class SelectInLoader(PostLoader, util.MemoizedSlots): q = sql.lambda_stmt( lambda: sql.select( orm_util.Bundle("pk", *pk_cols), effective_entity - ).apply_labels(), + ) + .apply_labels() + ._set_propagate_attrs( + { + "compile_state_plugin": "orm", + "plugin_subject": effective_entity, + } + ), lambda_cache=self._query_cache, global_track_bound_values=False, track_on=(self, effective_entity) + tuple(pk_cols), diff --git a/lib/sqlalchemy/orm/util.py b/lib/sqlalchemy/orm/util.py index 7d1650a1a1..4502d5b891 100644 --- a/lib/sqlalchemy/orm/util.py +++ b/lib/sqlalchemy/orm/util.py @@ -1361,11 +1361,26 @@ class Bundle(ORMColumnsClauseRole, SupportsCloneAnnotations, InspectionAttr): # ensure existing entity_namespace remains annotations = {"bundle": self, "entity_namespace": self} annotations.update(self._annotations) - return expression.ClauseList( - _literal_as_text_role=roles.ColumnsClauseRole, - group=False, - *[e._annotations.get("bundle", e) for e in self.exprs] - )._annotate(annotations) + + plugin_subject = self.exprs[0]._propagate_attrs.get( + "plugin_subject", self.entity + ) + return ( + expression.ClauseList( + _literal_as_text_role=roles.ColumnsClauseRole, + group=False, + *[e._annotations.get("bundle", e) for e in self.exprs] + ) + ._annotate(annotations) + ._set_propagate_attrs( + # the Bundle *must* use the orm plugin no matter what. the + # subject can be None but it's much better if it's not. + { + "compile_state_plugin": "orm", + "plugin_subject": plugin_subject, + } + ) + ) @property def clauses(self): diff --git a/lib/sqlalchemy/sql/traversals.py b/lib/sqlalchemy/sql/traversals.py index a24d010cdd..2887813adf 100644 --- a/lib/sqlalchemy/sql/traversals.py +++ b/lib/sqlalchemy/sql/traversals.py @@ -176,7 +176,9 @@ class HasCacheKey(object): obj["compile_state_plugin"], obj["plugin_subject"]._gen_cache_key( anon_map, bindparams - ), + ) + if obj["plugin_subject"] + else None, ) elif meth is InternalTraversal.dp_annotations_key: # obj is here is the _annotations dict. however, we diff --git a/test/orm/test_bundle.py b/test/orm/test_bundle.py index 49feb32f0b..956645506f 100644 --- a/test/orm/test_bundle.py +++ b/test/orm/test_bundle.py @@ -247,7 +247,7 @@ class BundleTest(fixtures.MappedTest, AssertsCompiledSQL): ], ) - def test_single_entity(self): + def test_single_entity_legacy_query(self): Data = self.classes.Data sess = Session() @@ -258,12 +258,80 @@ class BundleTest(fixtures.MappedTest, AssertsCompiledSQL): [("d3d1", "d3d2"), ("d4d1", "d4d2"), ("d5d1", "d5d2")], ) - def test_single_entity_future(self): + def test_labeled_cols_non_single_entity_legacy_query(self): + Data = self.classes.Data + sess = Session() + + b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y")) + + eq_( + sess.query(b1).filter(b1.c.x.between("d3d1", "d5d1")).all(), + [(("d3d1", "d3d2"),), (("d4d1", "d4d2"),), (("d5d1", "d5d2"),)], + ) + + def test_labeled_cols_single_entity_legacy_query(self): + Data = self.classes.Data + sess = Session() + + b1 = Bundle( + "b1", Data.d1.label("x"), Data.d2.label("y"), single_entity=True + ) + + eq_( + sess.query(b1).filter(b1.c.x.between("d3d1", "d5d1")).all(), + [("d3d1", "d3d2"), ("d4d1", "d4d2"), ("d5d1", "d5d2")], + ) + + def test_labeled_cols_as_rows_future(self): + Data = self.classes.Data + sess = Session() + + b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y")) + + stmt = select(b1).filter(b1.c.x.between("d3d1", "d5d1")) + + eq_( + sess.execute(stmt).all(), + [(("d3d1", "d3d2"),), (("d4d1", "d4d2"),), (("d5d1", "d5d2"),)], + ) + + def test_labeled_cols_as_scalars_future(self): + Data = self.classes.Data + sess = Session() + + b1 = Bundle("b1", Data.d1.label("x"), Data.d2.label("y")) + + stmt = select(b1).filter(b1.c.x.between("d3d1", "d5d1")) + eq_( + sess.execute(stmt).scalars().all(), + [("d3d1", "d3d2"), ("d4d1", "d4d2"), ("d5d1", "d5d2")], + ) + + def test_single_entity_flag_is_legacy_w_future(self): Data = self.classes.Data sess = Session(testing.db, future=True) + # flag has no effect b1 = Bundle("b1", Data.d1, Data.d2, single_entity=True) + stmt = select(b1).filter(b1.c.d1.between("d3d1", "d5d1")) + + with testing.expect_deprecated_20( + "The Bundle.single_entity flag has no effect when " + "using 2.0 style execution." + ): + rows = sess.execute(stmt).all() + eq_( + rows, + [(("d3d1", "d3d2"),), (("d4d1", "d4d2"),), (("d5d1", "d5d2"),)], + ) + + def test_as_scalars_future(self): + Data = self.classes.Data + sess = Session(testing.db) + + b1 = Bundle("b1", Data.d1, Data.d2) + stmt = select(b1).filter(b1.c.d1.between("d3d1", "d5d1")) eq_( sess.execute(stmt).scalars().all(), @@ -446,3 +514,25 @@ class BundleTest(fixtures.MappedTest, AssertsCompiledSQL): "SELECT row_number() OVER (ORDER BY data.id, data.d1, data.d2) " "AS anon_1 FROM data", ) + + def test_non_mapped_columns_non_single_entity(self): + data_table = self.tables.data + + b1 = Bundle("b1", data_table.c.d1, data_table.c.d2) + + sess = Session() + eq_( + sess.query(b1).filter(b1.c.d1.between("d3d1", "d5d1")).all(), + [(("d3d1", "d3d2"),), (("d4d1", "d4d2"),), (("d5d1", "d5d2"),)], + ) + + def test_non_mapped_columns_single_entity(self): + data_table = self.tables.data + + b1 = Bundle("b1", data_table.c.d1, data_table.c.d2, single_entity=True) + + sess = Session() + eq_( + sess.query(b1).filter(b1.c.d1.between("d3d1", "d5d1")).all(), + [("d3d1", "d3d2"), ("d4d1", "d4d2"), ("d5d1", "d5d2")], + )