Refactor get columns.

Author: WaVEV

django_mongodb/compiler.py

@@ -44,33 +44,16 @@ def results_iter(
         """
         columns = self.get_columns()
 
-        related_columns = []
         if results is None:
             # QuerySet.values() or values_list()
             try:
                 results = self.build_query(columns).fetch()
             except EmptyResultSet:
                 results = []
-        else:
-            index = len(columns)
-            while index < self.col_count:
-                foreign_columns = []
-                foreign_relation = self.select[index][0].alias
-                while index < self.col_count and foreign_relation == self.select[index][0].alias:
-                    foreign_columns.append(self.select[index][0])
-                    index += 1
-                related_columns.append(
-                    (
-                        foreign_relation,
-                        [(column.target.column, column) for column in foreign_columns],
-                    )
-                )
 
         converters = self.get_converters(columns)
         for entity in results:
-            yield self._make_result(
-                entity, columns, related_columns, converters, tuple_expected=tuple_expected
-            )
+            yield self._make_result(entity, columns, converters, tuple_expected=tuple_expected)
 
     def has_results(self):
         return bool(self.get_count(check_exists=True))
@@ -89,17 +72,14 @@ def get_converters(self, expressions):
                 converters[name] = backend_converters + field_converters
         return converters
 
-    def _make_result(self, entity, columns, related_columns, converters, tuple_expected=False):
+    def _make_result(self, entity, columns, converters, tuple_expected=False):
         """
         Decode values for the given fields from the database entity.
 
         The entity is assumed to be a dict using field database column
         names as keys.
         """
         result = self._apply_converters(entity, columns, converters)
-        # Related columns.
-        for relation, columns in related_columns:
-            result += self._apply_converters(entity[relation], columns, converters)
         if tuple_expected:
             result = tuple(result)
         return result
@@ -108,7 +88,12 @@ def _apply_converters(self, entity, columns, converters):
         result = []
         for name, col in columns:
             field = col.field
-            value = entity.get(name, NOT_PROVIDED)
+            obj = (
+                entity.get(col.alias, {})
+                if hasattr(col, "alias") and col.alias != self.collection_name
+                else entity
+            )
+            value = obj.get(name, NOT_PROVIDED)
             if value is NOT_PROVIDED:
                 value = field.get_default()
             elif converters:
@@ -173,9 +158,17 @@ def get_columns(self):
         columns = (
             self.get_default_columns(select_mask) if self.query.default_cols else self.query.select
         )
+
+        related_columns = []
+        if self.query.select_related:
+            self.get_related_selections(related_columns, select_mask)
+            if related_columns:
+                related_columns, _ = zip(*related_columns, strict=True)
+
         annotation_idx = 1
-        result = []
-        for column in columns:
+
+        def project_field(column):
+            nonlocal annotation_idx
             if hasattr(column, "target"):
                 # column is a Col.
                 target = column.target.column
@@ -184,8 +177,13 @@ def get_columns(self):
                 # name for $proj.
                 target = f"__annotation{annotation_idx}"
                 annotation_idx += 1
-            result.append((target, column))
-        return tuple(result) + tuple(self.query.annotation_select.items())
+            return target, column
+
+        return (
+            tuple(map(project_field, columns))
+            + tuple(self.query.annotation_select.items())
+            + tuple(map(project_field, related_columns))
+        )
 
     def _get_ordering(self):
         """

django_mongodb/features.py

@@ -153,23 +153,9 @@ def django_test_expected_failures(self):
             "model_fields.test_autofield.SmallAutoFieldTests",
         },
         "QuerySet.select_related() not supported.": {
-            "annotations.tests.AliasTests.test_joined_alias_annotation",
-            "annotations.tests.NonAggregateAnnotationTestCase.test_joined_annotation",
-            "defer.tests.DeferTests.test_defer_foreign_keys_are_deferred_and_not_traversed",
-            "defer.tests.DeferTests.test_defer_with_select_related",
-            "defer.tests.DeferTests.test_only_with_select_related",
-            "defer.tests.TestDefer2.test_defer_proxy",
-            "defer_regress.tests.DeferRegressionTest.test_basic",
             "defer_regress.tests.DeferRegressionTest.test_common_model_different_mask",
-            "model_fields.test_booleanfield.BooleanFieldTests.test_select_related",
-            "model_fields.test_foreignkey.ForeignKeyTests.test_empty_string_fk",
             "defer_regress.tests.DeferRegressionTest.test_defer_annotate_select_related",
-            "defer_regress.tests.DeferRegressionTest.test_defer_with_select_related",
-            "defer_regress.tests.DeferRegressionTest.test_only_with_select_related",
-            "defer_regress.tests.DeferRegressionTest.test_proxy_model_defer_with_select_related",
             "defer_regress.tests.DeferRegressionTest.test_reverse_one_to_one_relations",
-            "defer_regress.tests.DeferRegressionTest.test_ticket_23270",
-            "ordering.tests.OrderingTests.test_ordering_select_related_collision",
         },
         "MongoDB does not enforce UNIQUE constraints.": {
             "auth_tests.test_basic.BasicTestCase.test_unicode_username",
@@ -307,23 +293,13 @@ def django_test_expected_failures(self):
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_and_alias_filter_related_in_subquery",
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_filter_with_subquery",
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_reverse_m2m",
-            "annotations.tests.NonAggregateAnnotationTestCase.test_joined_transformed_annotation",
             "annotations.tests.NonAggregateAnnotationTestCase.test_mti_annotations",
             "annotations.tests.NonAggregateAnnotationTestCase.test_values_with_pk_annotation",
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_subquery_outerref_transform",
             "annotations.tests.NonAggregateAnnotationTestCase.test_annotation_with_m2m",
             "annotations.tests.NonAggregateAnnotationTestCase.test_chaining_annotation_filter_with_m2m",
             "db_functions.comparison.test_least.LeastTests.test_related_field",
             "db_functions.comparison.test_greatest.GreatestTests.test_related_field",
-            "defer.tests.BigChildDeferTests.test_defer_baseclass_when_subclass_has_added_field",
-            "defer.tests.BigChildDeferTests.test_defer_subclass",
-            "defer.tests.BigChildDeferTests.test_defer_subclass_both",
-            "defer.tests.BigChildDeferTests.test_only_baseclass_when_subclass_has_added_field",
-            "defer.tests.BigChildDeferTests.test_only_subclass",
-            "defer.tests.DeferTests.test_defer_baseclass_when_subclass_has_no_added_fields",
-            "defer.tests.DeferTests.test_defer_of_overridden_scalar",
-            "defer.tests.DeferTests.test_only_baseclass_when_subclass_has_no_added_fields",
-            "defer.tests.TestDefer2.test_defer_inheritance_pk_chaining",
             "defer_regress.tests.DeferRegressionTest.test_ticket_16409",
             "expressions_case.tests.CaseExpressionTests.test_annotate_with_aggregation_in_condition",
             "expressions_case.tests.CaseExpressionTests.test_annotate_with_aggregation_in_predicate",
@@ -335,9 +311,6 @@ def django_test_expected_failures(self):
             "expressions_case.tests.CaseExpressionTests.test_filter_with_aggregation_in_condition",
             "expressions_case.tests.CaseExpressionTests.test_filter_with_aggregation_in_predicate",
             "expressions_case.tests.CaseExpressionTests.test_filter_with_aggregation_in_value",
-            "expressions_case.tests.CaseExpressionTests.test_filter_with_join_in_condition",
-            "expressions_case.tests.CaseExpressionTests.test_filter_with_join_in_predicate",
-            "expressions_case.tests.CaseExpressionTests.test_filter_with_join_in_value",
             "expressions_case.tests.CaseExpressionTests.test_join_promotion",
             "expressions_case.tests.CaseExpressionTests.test_join_promotion_multiple_annotations",
             "expressions_case.tests.CaseExpressionTests.test_m2m_exclude",
@@ -347,10 +320,7 @@ def django_test_expected_failures(self):
             "lookup.tests.LookupTests.test_filter_by_reverse_related_field_transform",
             "lookup.tests.LookupTests.test_lookup_collision",
             "lookup.tests.LookupTests.test_lookup_rhs",
-            "lookup.tests.LookupTests.test_isnull_non_boolean_value",
             "model_fields.test_jsonfield.TestQuerying.test_join_key_transform_annotation_expression",
-            "model_fields.test_manytomanyfield.ManyToManyFieldDBTests.test_value_from_object_instance_with_pk",
-            "model_fields.test_uuid.TestAsPrimaryKey.test_two_level_foreign_keys",
             "ordering.tests.OrderingTests.test_default_ordering",
             "ordering.tests.OrderingTests.test_order_by_expr_query_reuse",
             "ordering.tests.OrderingTests.test_order_by_fk_attname",
@@ -361,18 +331,15 @@ def django_test_expected_failures(self):
             "ordering.tests.OrderingTests.test_order_by_ptr_field_with_default_ordering_by_expression",
             "ordering.tests.OrderingTests.test_order_by_self_referential_fk",
             "ordering.tests.OrderingTests.test_orders_nulls_first_on_filtered_subquery",
-            "ordering.tests.OrderingTests.test_related_ordering_duplicate_table_reference",
             "ordering.tests.OrderingTests.test_reverse_meta_ordering_pure",
             "ordering.tests.OrderingTests.test_reversed_ordering",
             "timezones.tests.LegacyDatabaseTests.test_query_annotation",
             "timezones.tests.NewDatabaseTests.test_query_annotation",
             "update.tests.AdvancedTests.test_update_annotated_multi_table_queryset",
-            "update.tests.AdvancedTests.test_update_fk",
             "update.tests.AdvancedTests.test_update_ordered_by_inline_m2m_annotation",
             "update.tests.AdvancedTests.test_update_ordered_by_m2m_annotation",
             "update.tests.AdvancedTests.test_update_ordered_by_m2m_annotation_desc",
             "update.tests.SimpleTest.test_empty_update_with_inheritance",
-            "update.tests.SimpleTest.test_foreign_key_update_with_id",
             "update.tests.SimpleTest.test_nonempty_update_with_inheritance",
         },
         "Test inspects query for SQL": {