Strawberry GraphQL：如何基于子解析器过滤及关联解析逻辑？

问题1：基于子字段engaged过滤顶层users列表 #

核心矛盾是engaged有独立解析器，但要在users顶层查询中用它过滤，直接调用解析器方法会绕开Dataloader，降低执行效率。

解决方案 #

1. 抽离共享业务逻辑

把engaged的判断逻辑从解析器中独立出来，同时供给字段解析和顶层过滤使用：

from datetime import datetime, timedelta
from sqlalchemy import select
import strawberry
from your_models import UserModel

# 独立的业务判断函数
def is_user_engaged(user: UserModel) -> bool:
    return user.last_active > datetime.utcnow() - timedelta(days=7)

@strawberry.type
class User:
    id: strawberry.ID
    name: str

    @strawberry.field
    def engaged(self) -> bool:
        return is_user_engaged(self._instance)  # _instance为SQLAlchemy模型实例

# 定义过滤参数类型
@strawberry.input
class UserFilter:
    engaged: bool | None = None

@strawberry.type
class Query:
    @strawberry.field
    async def users(self, filter: UserFilter, db_session) -> list[User]:
        query = select(UserModel)
        if filter.engaged is not None:
            # 将业务逻辑转换为SQL查询条件，直接在数据库层面过滤
            time_threshold = datetime.utcnow() - timedelta(days=7)
            if filter.engaged:
                query = query.where(UserModel.last_active > time_threshold)
            else:
                query = query.where(UserModel.last_active <= time_threshold)
        
        users = await db_session.scalars(query)
        return [User.from_instance(user) for user in users]

2. 优先用SQL层面过滤（推荐）

如果engaged的判断逻辑能转换成SQL表达式，直接在数据库层面完成过滤是最高效的方案，既避免内存二次过滤的开销，也能完全配合strawberry-sqlalchemy-mapper的查询优化。

问题2：解析器复用兄弟/子字段的结果 #

需要shipping_time字段复用home_address和work_address的解析结果，避免重复调用和低效执行。

解决方案 #

1. 利用SQLAlchemy预加载关联数据

通过SQLAlchemy的预加载功能，在查询User时提前加载关联的地址数据，解析器直接使用已加载的对象：

from sqlalchemy.orm import selectinload
import strawberry
from your_models import UserModel, AddressModel

@strawberry.type
class Address:
    id: strawberry.ID
    shipping_time: int

    @classmethod
    def from_instance(cls, instance: AddressModel):
        return cls(id=instance.id, shipping_time=instance.shipping_time)

@strawberry.type
class User:
    id: strawberry.ID
    name: str
    home_address: Address
    work_address: Address

    @strawberry.field
    def shipping_time(self) -> int:
        # 直接使用预加载的地址数据，无需额外查询
        return min(self.home_address.shipping_time, self.work_address.shipping_time)

@strawberry.type
class Query:
    @strawberry.field
    async def users(self, db_session) -> list[User]:
        # 预加载地址关联，避免N+1查询
        query = select(UserModel).options(
            selectinload(UserModel.home_address),
            selectinload(UserModel.work_address)
        )
        users = await db_session.scalars(query)
        return [User.from_instance(user) for user in users]

这种方式完全依托SQLAlchemy的预加载机制，Strawberry执行引擎会直接使用已加载的数据，不会触发额外查询。

2. 实例内缓存已加载数据

在User类型实例中添加临时属性，缓存已加载的兄弟字段数据：

import strawberry

@strawberry.type
class Address:
    id: strawberry.ID
    shipping_time: int

@strawberry.type
class User:
    id: strawberry.ID
    name: str
    _home_address: Address | None = None
    _work_address: Address | None = None

    @strawberry.field
    async def home_address(self) -> Address:
        if self._home_address is None:
            self._home_address = await fetch_home_address(self.id)
        return self._home_address

    @strawberry.field
    async def work_address(self) -> Address:
        if self._work_address is None:
            self._work_address = await fetch_work_address(self.id)
        return self._work_address

    @strawberry.field
    async def shipping_time(self) -> int:
        # 复用已缓存的地址数据
        home_addr = await self.home_address()
        work_addr = await self.work_address()
        return min(home_addr.shipping_time, work_addr.shipping_time)

Strawberry的类型实例为每个请求独立创建，不会有并发冲突，调用已加载的字段时会直接返回缓存值，无需重复执行解析逻辑。

内容的提问来源于stack exchange，提问作者Matt