RavenDB Transformer 包含文档列表

Question

我有点坚持使用包含与 RavenDB 转换器。假设我有以下文档类:

public class Processor
{
    public string Id { get; set; }
    // other properties
}

public class Job
{
    public string Id { get; set; }
    public string ProcessorId { get; set; }
    // other properties
}

她是我的 View 模型:

public class ProcessorStatsViewModel
{
    public string Id { get; set; }
    public int JobCount { get; set; }
    // other properties
}

在我的转换器中，我想查询 Processors Document Store 并在 Jobs Store 中包含一个包含匹配处理器 ID 的作业。我找到的所有搜索结果都描述了当 Processor 类具有 JobId 列表时如何执行此操作。有没有办法在 RavenDB 中做到这一点？

我想要的变压器看起来像:

public Processors_StatsViewModel()
{
    TransformerResults = procs => 
        from p in procs
        let jobs = Include<Jobs>(p.Id) // how can i specify something like where p.Id == j.ProcessorId ?
        select new
        {
            p.Id
            JobCount = jobs.Count
            // other stuff
        }
}

所有 Transformer LoadDocument、Include 和 Recurse 方法都希望被查询的类具有列表引用 ID，但在我的情况下需要相反的 ID。

这是我什至可以在 RavenDB 中做的事情还是我错过了什么？

Answer 1

你不能只用一个转换器和你当前的域模型做你想做的事情。如果处理器确实知道它的工作，你可以用一种类似于你所拥有的变压器来做到这一点。

但是，您可以使用 Map/Reduce 索引实现类似的效果，然后在 Map/Reduce 索引的结果上使用 Transformer。这一切都取决于您想要呈现的“其他东西”，但这是一种获取所有进程及其作业计数，然后使用转换器添加更多信息的方法:

映射/减少索引以按处理器获取作业计数:

public class Jobs_ByProcessor : AbstractIndexCreationTask<Job, Jobs_ByProcessor.ReduceResult>
{
    public class ReduceResult
    {
        public string ProcessorId { get; set; }
        public int JobCount { get; set; }
    }

    public Jobs_ByProcessor()
    {
        Map = jobs => from job in jobs
                      select new ReduceResult
                      {
                          ProcessorId = job.ProcessorId,
                          JobCount = 1
                      };

        Reduce = results => from result in results
                            group result by result.ProcessorId
                                into g
                                select new
                                {
                                    ProcessorId = g.Key,
                                    JobCount = g.Sum(x => x.JobCount)
                                };
    }
}

变压器:

public class ProcessorJobTransformer : AbstractTransformerCreationTask<Jobs_ByProcessor.ReduceResult>
{
    public ProcessorJobTransformer()
    {
        TransformResults = results => from result in results
            let processor = LoadDocument<Processor>(result.ProcessorId)
            select new
            {
                Id = result.ProcessorId,
                Name = processor.Name,
                JobCount = result.JobCount
            };
    }
}

这会给你一个这样的结果:

Id 和 JobCount 来自索引的 Reduce 结果，Name 来自 Transformer(通过 LoadDocument)。

但是，如果您需要此结果但需要来自 Job 文档的更多信息，则可能必须完全采用不同的方法。

希望这可以帮助!