Method _load_via_child

lib/sqlalchemy/orm/strategies.py:3408–3463

(
        self,
        our_states,
        none_states,
        query_info,
        q,
        context,
        execution_options,
        chunksize,
    )

            )

    def _load_via_child(
        self,
        our_states,
        none_states,
        query_info,
        q,
        context,
        execution_options,
        chunksize,
    ):
        uselist = self.uselist
        n_pk = query_info.n_pk

        # this sort is really for the benefit of the unit tests
        our_keys = sorted(our_states)
        while our_keys:
            chunk = our_keys[0:chunksize]
            our_keys = our_keys[chunksize:]
            primary_keys = [
                key[0] if query_info.zero_idx else key for key in chunk
            ]
            result = context.session.execute(
                q,
                params={"primary_keys": primary_keys},
                execution_options=execution_options,
            )
            if result.context is not None and result.context.requires_uniquing:
                rows = result.unique()
            else:
                rows = result._raw_all_tuples()
            data = {row[:n_pk]: row[n_pk] for row in rows}

            for key in chunk:
                # for a real foreign key and no concurrent changes to the
                # DB while running this method, "key" is always present in
                # data.  However, for primaryjoins without real foreign keys
                # a non-None primaryjoin condition may still refer to no
                # related object.
                related_obj = data.get(key, None)
                for state, dict_, overwrite in our_states[key]:
                    if not overwrite and self.key in dict_:
                        continue

                    state.get_impl(self.key).set_committed_value(
                        state,
                        dict_,
                        related_obj if not uselist else [related_obj],
                    )
        # populate none states with empty value / collection
        for state, dict_, overwrite in none_states:
            if not overwrite and self.key in dict_:
                continue

            # note it's OK if this is a uselist=True attribute, the empty
            # collection will be populated
            state.get_impl(self.key).set_committed_value(state, dict_, None)

    def _load_via_parent(