3

这个问题基于https://github.com/ChilliCream/hotchocolate/issues/924中的讨论——这也是我获得灵感的地方。

我有一个系统，其中我保留了一份员工名单。每个员工都有一个 WorkHours 属性，表示您每周工作多少小时。

我还有一系列需要由前面提到的员工解决的任务。

该关联是通过分配类处理的。此类包含两个 unix 时间戳 Start 和 End ，表示员工在哪个时间段内处理特定任务。此外，他们有一个 HoursPerWeek 属性，表示员工每周必须在给定任务上花费多少小时，HoursPerWeek 是必要的，因为只要 Allocation.HoursPerWeek 的总和，员工就可以在同一时间段内与多个任务相关联不超过 Employee.WorkHours。

本质上，我想按照这个 LINQ 查询的方式实现一些目标

var ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
employees.Where(e =>
    e.Allocations
        .Where(a => a.Start < ts && a.End > ts)
        .Sum(a => a.HoursPerWeek)
    < e.WorkHours);

这将有效地给我任何在这个时间点剩余工作时间的员工。

我无法在我的查询中直接引用employee.WorkHours，但我试图让它与双打相比工作。这就是我现在已经走了多远

public class CustomFilterConventionExtension : FilterConventionExtension
{
    protected override void Configure(IFilterConventionDescriptor descriptor)
    {
        descriptor.Operation(CustomFilterOperations.Sum)
            .Name("sum");

        descriptor.Configure<ListFilterInputType<FilterInputType<Allocation>>>(descriptor =>
        {
            descriptor
                .Operation(CustomFilterOperations.Sum)
                .Type<ComparableOperationFilterInputType<double>>();
        });

        descriptor.AddProviderExtension(new QueryableFilterProviderExtension(
            y =>
            {
                y.AddFieldHandler<EmployeeAllocationSumOperationHandler>();
            }));
    }
}

public class EmployeeAllocationSumOperationHandler : FilterOperationHandler<QueryableFilterContext, Expression>
{
    public override bool CanHandle(ITypeCompletionContext context, IFilterInputTypeDefinition typeDefinition,
        IFilterFieldDefinition fieldDefinition)
    {
        return context.Type is IListFilterInputType &&
               fieldDefinition is FilterOperationFieldDefinition { Id: CustomFilterOperations.Sum };
    }

    public override bool TryHandleEnter(QueryableFilterContext context, IFilterField field, ObjectFieldNode node, [NotNullWhen(true)] out ISyntaxVisitorAction? action)
    {
        var ts = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
        var property = context.GetInstance();

        Expression<Func<ICollection<Allocation>, double>> expression = _ => _
            .Where(_ => _.Start < ts && _.End > ts)
            .Sum(_ => _.HoursPerWeek);
        var invoke = Expression.Invoke(expression, property);
        context.PushInstance(invoke);
        action = SyntaxVisitor.Continue;
        return true;
    }
}

services.AddGraphQLServer()
    .AddQueryType<EmployeeQuery>()
    .AddType<EmployeeType>()
    .AddProjections()
    .AddFiltering()
    .AddConvention<IFilterConvention, CustomFilterConventionExtension>()
    .AddSorting();

有了它，我然后尝试编写我的查询

employees (where: {allocations: {sum: {gt: 5}}}) {
  nodes{
    id, name
  }
}

但是，此实现会不断抛出异常，因为它无法从System.Obejctto 转换System.Generic.IEnumerable。

但是在最终版本中，我希望能够不使用 const 编号而是使用 Employee WorkHours 进行查询

employees (where: {allocations: {sum: {gt: workHours}}}) {
  nodes{
    id, name
  }
}

谁能协助创建一个过滤器操作？也许你做过类似的事情，或者知道这实际上是不可能的。

如果有人想玩它，我已经将我所有的代码都放在了 GitHub 存储库中https://github.com/LordLyng/sum-filter-example

4

1 回答 1

0

我仍然没有找到使用实际聚合的解决方案。但是我找到了一种在数据库级别而不是在 GraphQL 中解决我的特定问题的方法。

我最终为我的 Entitypublic bool Available { get; set; }和public double AvailableHours { get; set; }. 添加这些道具后，我为员工实体编辑了我的 EntityTypeConfiguration。在这里，我添加了以下几行。请原谅我的 SQL，我还很不流利；）

builder.Property(e => e.Available)
    .HasComputedColumnSql("CASE WHEN [WorkHours] > [dbo].[AllocSumForEmployee] ([Id]) THEN CAST(1 AS BIT) ELSE CAST(0 AS BIT) END", stored: false)
    .ValueGeneratedOnAddOrUpdate();
builder.Property(e => e.AvailableHours)
    .HasComputedColumnSql("IIF([WorkHours] - [dbo].[AllocSumForEmployee] ([Id]) > 0, [WorkHours] - [dbo].[AllocSumForEmployee] ([Id]), 0)", stored: false)
    .ValueGeneratedOnAddOrUpdate();

这里发生了几件事 - 首先，我们将一个计算列添加到我们的数据库模式中。其次，我们添加ValueGeneratedOnAddOrUpdate方法以确保这些值不是由我们的应用程序设置，而是留给数据库处理。

计算列方法在单个表中的单个行的上下文中工作，因此默认情况下现在可以查询其他表或行。这正是我解决问题所需要的。

目光敏锐的观察者可能已经注意到，我在计算列中使用了一些看起来非常像方法的东西。而事实上，仅仅是这样。

我知道我会做很多基于的分配查找Start，End所以我索引了这些并通过运行创建我的迁移dotnet ef migrations add "<migration name">。剩下要做的就是修改生成的迁移。

编辑后的迁移最终看起来如下

protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql(@"
        CREATE FUNCTION [dbo].[AllocSumForEmployee] (@id nvarchar(36))
        RETURNS Float
        AS 
        BEGIN
        RETURN 
            (SELECT COALESCE(SUM([HoursPerWeek]), 0) FROM [Allocations]
                WHERE 
                    [Start] < DATEDIFF_BIG(MILLISECOND,'1970-01-01 00:00:00.000', SYSUTCDATETIME()) AND 
                    [End] > DATEDIFF_BIG(MILLISECOND,'1970-01-01 00:00:00.000', SYSUTCDATETIME()) AND
                    [EmployeeId] = @id)
        END
    ");

    migrationBuilder.AddColumn<bool>(
        name: "Available",
        table: "Employees",
        type: "bit",
        nullable: false,
        computedColumnSql: "CASE WHEN [WorkHours] > [dbo].[AllocSumForEmployee] ([Id]) THEN CAST(1 AS BIT) ELSE CAST(0 AS BIT) END",
        stored: false);

    migrationBuilder.AddColumn<double>(
        name: "AvailableHours",
        table: "Employees",
        type: "float",
        nullable: false,
        computedColumnSql: "IIF([WorkHours] - [dbo].[AllocSumForEmployee] ([Id]) > 0, [WorkHours] - [dbo].[AllocSumForEmployee] ([Id]), 0)",
        stored: false);

    migrationBuilder.CreateIndex(
        name: "IX_Allocations_End",
        table: "Allocations",
        column: "End");

    migrationBuilder.CreateIndex(
        name: "IX_Allocations_Start",
        table: "Allocations",
        column: "Start");
}

protected override void Down(MigrationBuilder migrationBuilder)
{
    migrationBuilder.DropIndex(
        name: "IX_Allocations_End",
        table: "Allocations");

    migrationBuilder.DropIndex(
        name: "IX_Allocations_Start",
        table: "Allocations");

    migrationBuilder.DropColumn(
        name: "Available",
        table: "Employees");

    migrationBuilder.DropColumn(
        name: "AvailableHours",
        table: "Employees");

    migrationBuilder.Sql("DROP FUNCTION [dbo].[AllocSumForEmployee]");
}

我添加的“唯一”不是自动生成的东西是 Up 方法的第一部分和 Down 方法的最后一部分。在 Up 中有效地注册一个用户定义的函数并在 Down 中删除该函数。

我的函数返回给定员工的 HoursPerWeek 所有分配的总和，其中 Start（存储为 ms 中的 unix 时间戳）在现在之前（DATEDIFF_BIG(MILLISECOND,'1970-01-01 00:00:00.000', SYSUTCDATETIME())是一种在 T-SQL 中将 now 获取为 ms 中的 unix 时间戳的方法），并且 End 在之后现在（即活动分配）。

这实际上意味着计算属性的计算是在数据库上完成的，而 HotChocolte 并不明智。它允许我做类似的查询

query {
  employees (where: {available: {eq: true}}) {
    nodes {
      id, name, available, availableHours
    }
  }
}

甚至

query {
  employees (where: {availableHours: {gt: 15}}) {
    nodes {
      id, name, available, availableHours
    }
  }
}

希望这可以帮助其他尝试使用聚合解决内联计算的人！

替代方法的代码可在此处获得https://github.com/LordLyng/sum-filter-example/tree/computed-prop-on-entity

于 2021-04-21T19:54:56.170 回答