Method _load_for_path

lib/sqlalchemy/orm/strategies.py:3180–3406

(
        self,
        context,
        path,
        states,
        load_only,
        effective_entity,
        loadopt,
        recursion_depth,
        execution_options,
    )

        )

    def _load_for_path(
        self,
        context,
        path,
        states,
        load_only,
        effective_entity,
        loadopt,
        recursion_depth,
        execution_options,
    ):
        if load_only and self.key not in load_only:
            return

        query_info = self._query_info

        if query_info.load_only_child:
            our_states = collections.defaultdict(list)
            none_states = []

            mapper = self.parent

            # attribute keys for the lookup columns; when these are
            # present in a state's dict, reading them directly is
            # equivalent to the PASSIVE_NO_FETCH attribute lookup below.
            # whether or not a key is present can vary per state, e.g.
            # individual instances may have the attribute expired or
            # deferred, so this is determined state-by-state
            get_related_ident = mapper._state_ident_getter(
                query_info.child_lookup_cols,
                passive=attributes.PASSIVE_NO_FETCH,
            )

            for state, overwrite in states:
                state_dict = state.dict
                related_ident = get_related_ident(state, state_dict)
                # if the loaded parent objects do not have the foreign key
                # to the related item loaded, then degrade into the joined
                # version of selectinload
                if LoaderCallableStatus.PASSIVE_NO_RESULT in related_ident:
                    query_info = self._fallback_query_info
                    break

                # organize states into lists keyed to particular foreign
                # key values.
                if None not in related_ident:
                    our_states[related_ident].append(
                        (state, state_dict, overwrite)
                    )
                else:
                    # For FK values that have None, add them to a
                    # separate collection that will be populated separately
                    none_states.append((state, state_dict, overwrite))

        # note the above conditional may have changed query_info
        if not query_info.load_only_child:
            our_states = [
                (state.key[1], state, state.dict, overwrite)