EF Core с GraphQL

В настоящее время я изучаю разработку GraphQL, и в настоящее время я изучаю, какие SQL-запросы генерируются с помощью EF Core, и я заметил, что независимо от того, что мой запрос GraphQL включает только несколько полей, EF Core отправляет SQL Select для всех полей Организация.

Это код, который я использую сейчас:

public class DoctorType : ObjectGraphType<Doctors>
{
    public DoctorType()
    {
            Field(d => d.PrefixTitle);
            Field(d => d.FName);
            Field(d => d.MName);
            Field(d => d.LName);
            Field(d => d.SufixTitle);
            Field(d => d.Image);
            Field(d => d.EGN);
            Field(d => d.Description);
            Field(d => d.UID_Code); 
    }
}

public class Doctors : ApplicationUser
{
    public string Image { get; set; }
    [StringLength(50)]
    public string UID_Code { get; set; }
}

запрос, который я использую,

{
  doctors{
    fName
    lName
  }
}

Сгенерированный SQL выбирает все поля объекта Doctor.

Есть ли способ дальнейшей оптимизации сгенерированного SQL-запроса из EF Core?

Я предполагаю, что это происходит потому, что DoctorType наследуется от ObjectGraphType<Doctors>, а не от какой-то проекции Доктора, но я не могу придумать умного обходного пути?

Какие-либо предложения?

Обновлено:

Я использую GraphQL.NET (graphql-dotnet) Джо Макбрайда версии 2.4.0.

Обновлено еще раз:

Либо я делаю это неправильно, либо я не знаю.

Как предложил один из комментариев, я скачал пакет GraphQL.EntityFramework Nuget от SimonCropp.

Я сделал всю необходимую для этого настройку:

        services.AddDbContext<ScheduleDbContext>(options =>
        {
            options.UseMySql(Configuration.GetConnectionString("DefaultConnection"));
        });

        using (var myDataContext = new ScheduleDbContext())
        {
            EfGraphQLConventions.RegisterInContainer(services, myDataContext);
        }

Мой тип графа объекта выглядит следующим образом

public class SpecializationType : EfObjectGraphType<Specializations>
{
    public SpecializationType(IEfGraphQLService graphQlService)
        :base(graphQlService)
    {
        Field(p => p.SpecializationId);
        Field(p => p.Code);
        Field(p => p.SpecializationName);
    }
}

Мой запрос выглядит так:

public class RootQuery : EfObjectGraphType
{
    public RootQuery(IEfGraphQLService efGraphQlService,
        ScheduleDbContext dbContext) : base(efGraphQlService)
    {
        Name = "Query";

        AddQueryField<SpecializationType, Specializations>("specializationsQueryable", resolve: ctx => dbContext.Specializations);

    }
}

и я использую этот запрос graphQL

{
  specializationsQueryable
  {
    specializationName
  }
}

Журнал отладки показывает, что сгенерированный SQL-запрос

SELECT `s`.`SpecializationId`, `s`.`Code`, `s`.`SpecializationName`
FROM `Specializations` AS `s`

хотя мне нужно только поле specializationName, и я ожидаю, что оно будет:

SELECT `s`.`SpecializationName`
FROM `Specializations` AS `s`

ОБНОВИТЬ

Думаю, до сих пор я не понимал, как на самом деле работает graphQL. Я думал, что есть какая-то закулисная выборка данных, но это не так.

Первичная выборка выполняется в преобразователе полей запроса:

FieldAsync<ListGraphType<DoctorType>>("doctors", resolve: async ctx => await doctorServices.ListAsync());

и пока результат для распознавателя является полным объектом, в моем случае распознаватель возвращает список объектов Doctors, он будет запрашивать базу данных для всего объекта (все поля). Из GraphQL не делается никаких оптимизаций, не имеет значения, возвращаете ли вы IQueryable или объект, который вы запрашиваете.

Каждый вывод здесь мой, он не гарантируется на 100% правильным

Итак, что я сделал, так это создал группу вспомогательных методов, которые создают выражение выбора для использования в запросе LINQ. Помощники используют свойство context.SubFields преобразователя для получения необходимых полей.

Проблема в том, что вам нужны для каждого уровня запроса только листья, скажем некоторые запросы "специализации" с "SpecializationName" и "Код" и "Врачи" с их "Имя" и прочее. В этом случае в распознавателе поля специализации RootQuery вам нужна только проекция объекта Specializations, поэтому: SpecializationName и Code , затем, когда он переходит к выборке всех Doctors из поля «доктора» в SpecializationType, контекст распознавателя имеет разные подполя, которые следует использовать для проекция Doctor.

Проблема с вышеизложенным заключается в том, что когда вы используете пакеты запросов, я думаю, даже если вы этого не сделаете, дело в том, что поле Doctors в SpecializationType нуждается в SpecializationId, извлеченном из поля специализации RootQuery.

Наверное, я плохо объяснил, через что я прошел.

Насколько я понимаю, базовая линия заключается в том, что мы должны динамически создавать селекторы, которые linq должен использовать для проецирования объекта.

Я публикую свой подход здесь:

    public class RootQuery : EfObjectGraphType
{
    public RootQuery(IEfGraphQLService efGraphQlService, ISpecializationGraphQlServices specializationServices,
        IDoctorGraphQlServices doctorServices, ScheduleDbContext dbContext) : base(efGraphQlService)
    {
        Name = "Query";

        FieldAsync<ListGraphType<SpecializationType>>("specializations"
            , resolve: async ctx => {

                var selectedFields = GraphQLResolverContextHelpers.GetFirstLevelLeavesNamesPascalCase(ctx.SubFields);
                var expression = BuildLinqSelectorObject.DynamicSelectGenerator<Specializations>(selectedFields.ToArray());

                return await specializationServices.ListAsync(selector: expression);
            });
    }
}

Тип специализации

 public class SpecializationType : EfObjectGraphType<Specializations>
{
    public SpecializationType(IEfGraphQLService graphQlService
        , IDataLoaderContextAccessor accessor, IDoctorGraphQlServices doctorServices)
        : base(graphQlService)
    {
        Field(p => p.SpecializationId);
        Field(p => p.Code);
        Field(p => p.SpecializationName);
        Field<ListGraphType<DoctorType>, IEnumerable<Doctors>>()
            .Name("doctors")
            .ResolveAsync(ctx =>
            {

                var selectedFields = GraphQLResolverContextHelpers.GetFirstLevelLeavesNamesPascalCase(ctx.SubFields);
                selectedFields = GraphQLResolverContextHelpers.AppendParrentNodeToEachItem(selectedFields, parentNode: "Doctor");
                selectedFields = selectedFields.Union(new[] { "Specializations_SpecializationId" });

                var expression = BuildLinqSelectorObject.BuildSelector<SpecializationsDoctors, SpecializationsDoctors>(selectedFields);

                var doctorsLoader = accessor.Context
                    .GetOrAddCollectionBatchLoader<int, Doctors>(
                        "GetDoctorsBySpecializationId"
                        , (collection, token) =>
                        {
                            return doctorServices.GetDoctorsBySpecializationIdAsync(collection, token, expression);
                        });
                return doctorsLoader.LoadAsync(ctx.Source.SpecializationId);
            });
    }
}

ВрачиУслуги:

public class DoctorGraphQlServices : IDoctorGraphQlServices
{
    public ScheduleDbContext _dbContext { get; set; }

    public DoctorGraphQlServices(ScheduleDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<List<Doctors>> ListAsync(int? specializationId = null)
    {
        var doctors = _dbContext.Doctors.AsQueryable();

        if (specializationId != null)
        {
            doctors = doctors.Where(d => d.Specializations.Any(s => s.Specializations_SpecializationId == specializationId));
        }

        return await doctors.ToListAsync();
    }

    public async Task<ILookup<int, Doctors>> GetDoctorsBySpecializationIdAsync(IEnumerable<int> specializationIds, CancellationToken token, Expression<Func<SpecializationsDoctors, SpecializationsDoctors>> selector = null)
    {
        var doctors = await _dbContext.SpecializationsDoctors
            .Include(s => s.Doctor)
            .Where(spDocs => specializationIds.Any(sp => sp == spDocs.Specializations_SpecializationId))
            .Select(selector: selector)
            .ToListAsync();

        return doctors.ToLookup(i => i.Specializations_SpecializationId, i => i.Doctor);
    }

}

СпециализацияУслуги

public class SpeciaizationGraphQlServices : ISpecializationGraphQlServices
{

    public ScheduleDbContext _dbContext { get; set; }

    public SpeciaizationGraphQlServices(ScheduleDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<dynamic> ListAsync(string doctorId = null, Expression<Func<Specializations, Specializations>> selector = null)
    {
        var specializations = _dbContext.Specializations.AsQueryable();

        if (!string.IsNullOrEmpty(doctorId))
        {
            specializations = specializations.Where(s => s.Doctors.Any(d => d.Doctors_Id == doctorId));
        }

        return await specializations.Select(selector).ToListAsync();

    }

    public async Task<ILookup<string, Specializations>> GetSpecializationsByDoctorIdAsync(IEnumerable<string> doctorIds, CancellationToken token)
    {
        var specializations = await _dbContext.SpecializationsDoctors
            .Include(s => s.Specialization)
            .Where(spDocs => doctorIds.Any(sp => sp == spDocs.Doctors_Id))
            .ToListAsync();

        return specializations.ToLookup(i => i.Doctors_Id, i => i.Specialization);
    }

    public IQueryable<Specializations> List(string doctorId = null)
    {
        var specializations = _dbContext.Specializations.AsQueryable();

        if (!string.IsNullOrEmpty(doctorId))
        {
            specializations = specializations.Where(s => s.Doctors.Any(d => d.Doctors_Id == doctorId));
        }

        return specializations;
    }
}

Этот пост стал довольно большим, извините за размах ..