7

我的同事问我，如果给出orderline示例，是否可以初始化如下所示的视图模型：

OrderViewModel
   string OrderId
   string CustomerName
   List<OrderLineViewModel> OrderLines

OrderLineViewModel
   string ProductName
   string ROI
   int Quantity

从索引？

我尝试进行转换以成功加载客户名称，但永远无法从订单行中获取相关的产品信息。这可以通过转换来完成，还是我需要从索引字段进行投影？

干杯，

詹姆士

编辑：

我们正在尝试直接从查询中填充视图模型。我们尝试了以下索引：

public class OrdersViewIndex : AbstractIndexCreationTask<Order>
{
   Map = orders => from order in orders
                   select new {
                                OrderId = order.id
                              };

   Transform = (database, orders) => from order in orders
                                     let customer = database.Load<Customer>(order.customerId)
                                     select new {
                                                  OrderId = order.id,
                                                  CustomerName = customer.Name,
                                                  OrderLines = // This is where I struggled to answer my colleagues questions as i'd need to load product name.
                                                }
}
4

1 回答 1

19

首先，要意识到所有索引都会自动将 映射Id到一个名为 的索引条目中__document_id。所以再次映射它并没有太大的价值。您在此索引映射中所做的只是将其再次复制到另一个名为OrderId.

其次，要了解转换并不是真正的索引的一部分，而只是附加到索引定义并在运行时执行。他们真正提供的只是一种在服务器上改变查询结果的方法。在大多数情况下，这些都是您可以在客户端执行的操作。

第三，索引用于查询非 id 字段，并提供可能陈旧但最终一致的结果。当您通过文档Id（也称为文档键）检索文档时，使用索引根本没有意义。您想改用该.Load()方法，它提供ACID保证，并且只从数据库中检索文档。

现在 - 当您的文档只有客户 ID 时，您遇到了如何获取客户名称的问题，以及如何获取产品名称而不仅仅是产品 ID。假设您的文档如下所示：

public class Order
{
    public string Id { get; set; }
    public string CustomerId { get; set; }
    public List<OrderLine> OrderLines { get; set; }
}

public class OrderLine
{
    public string ProductId { get; set; }
    public int Quantity { get; set; }
}

public class Customer
{
    public string Id { get; set; }
    public string Name { get; set; }
}

public class Product
{
    public string Id { get; set; }
    public string Name { get; set; }
}

如果您使用其 id 检索单个订单，您将执行以下操作：

var order = session.Load<Order>(theOrderId);

但是现在你想填充一些像这样的视图模型：

public class OrderVM
{
    public string OrderId { get; set; }
    public string CustomerId { get; set; }
    public string CustomerName { get; set; }
    public List<OrderLineVM> OrderLines { get; set; }
}

public class OrderLineVM
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}

您可以使用Includes来执行此操作。

var order = session.Include<Order>(x => x.CustomerId)
                   .Include<Order>(x => x.OrderLines.Select(y => y.ProductId))
                   .Load<Order>(theOrderId);

var orderViewModel = new OrderVM
{
    OrderId = order.Id,
    CustomerId = order.CustomerId,
    CustomerName = session.Load<Customer>(order.CustomerId).Name,
    OrderLines = order.OrderLines.Select(x => new OrderLineVM
                 {
                     ProductId = x.ProductId,
                     ProductName = session.Load<Product>(x.ProductId).Name,
                     Quantity = x.Quantity
                 })
};

尽管看到多次调用session.Load()，实际上只有一次调用数据库。.Include声明确保所有相关文档都在第一次调用时加载到会话中。随后的调用只是将其拉出本地会话。

以上所有内容都是为了通过其 id 检索单个订单。相反，如果您想获取所有订单，或获取特定客户的所有订单 -那么您需要查询。

对特定客户订单的动态查询如下所示：

var results = session.Query<Order>().Where(x => x.CustomerId == theCustomerId);

如果您想将这些投影到您的视图模型，就像您可以使用之前一样，包括：

var results = session.Query<Order>()
    .Customize(x => x.Include<Order>(y => y.CustomerId)
                     .Include<Order>(y => y.OrderLines.Select(z => z.ProductId)))
    .Where(x => x.CustomerId == theCustomerId)
    .Select(x => new OrderVM
    {
        OrderId = x.Id,
        CustomerId = x.CustomerId,
        CustomerName = session.Load<Customer>(x.CustomerId).Name,
        OrderLines = order.OrderLines.Select(y => new OrderLineVM
        {
            ProductId = y.ProductId,
            ProductName = session.Load<Product>(y.ProductId).Name,
            Quantity = y.Quantity
        })
    });

这确实有效，但您可能不想每次都写这个。此外，必须在会话中加载整个产品和客户记录，而您只需要每个字段中的一个字段。这是转换可能有用的地方。您可以按如下方式定义静态索引：

public class Orders_Transformed : AbstractIndexCreationTask<Order>
{
    public Orders_Transformed()
    {
        Map = orders => from order in orders select new { };

        TransformResults = (database, orders) =>
            from order in orders
            select new
            {
                OrderID = order.Id,
                CustomerID = order.CustomerId,
                CustomerName = database.Load<Customer>(order.CustomerId).Name,
                OrderLines = order.OrderLines.Select(y => new
                    {
                        ProductId = y.ProductId,
                        ProductName = database.Load<Product>(y.ProductId).Name,
                        Quantity = y.Quantity
                    })
            };
    }
}

现在，当您查询时，转换已经为您设置了数据。您只需指定要投影到的结果 VM。

var results = session.Query<Order, Orders_Transformed>().As<OrderVM>();

您可能已经注意到我在索引映射中根本没有包含任何字段。那是因为我没有尝试查询任何特定字段。所有数据都来自文档本身——索引中唯一的条目是自动添加的__document_id条目，Raven 使用这些条目来呈现来自文档存储的数据——用于返回或转换。

现在假设我想通过这些相关字段之一进行查询。例如，我想获取名为 Joe 的客户的所有订单。为此，我需要在索引中包含客户名称。RavenDB 2.0 添加了一项功能，使这变得非常容易——索引相关文档。

您将需要修改索引映射以使用该LoadDocument方法，如下所示：

Map = orders => from order in orders
                select new
                {
                    CustomerName = LoadDocument<Customer>(order.CustomerId)
                };

如果您愿意，您可以将其与 Includes 或 Transform 技术结合起来以获取完整视图模型。

另一种技术是从索引存储这些字段和项目。这对于像 . 这样的单个字段非常有效CustomerName，但对于像OrderLines.

最后，要考虑的另一种技术是反规范化。考虑一下，aProduct的名称可能已更改或被删除。您可能不想使以前的订单无效。将与订单相关的任何产品数据复制到OrderLine对象中是个好主意。

public class OrderLine
{
    public string ProductId { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

一旦你这样做了——你在检索订单时不再需要加载产品数据。Transform 部分变得不必要了，您只剩下一个简单的索引投影，如下所示：

public class Orders_ByCustomerName : AbstractIndexCreationTask<Order>
{
    public Orders_ByCustomerName()
    {
        Map = orders => from order in orders
                        select new
                        {
                          CustomerName = LoadDocument<Customer>(order.CustomerId).Name
                        };

        Store("CustomerName", FieldStorage.Yes);
    }
}

您可以通过以下方式轻松查询：

var results = session.Query<OrderVM, Orders_ByCustomerName>()
                     .Where(x => x.CustomerName == "Joe")
                     .As<OrderVM>();

请注意，在查询中，我第一次指定OrderVM时，我正在定义索引条目的形状。它只是设置了 lambda，所以我可以指定x.CustomerName == "Joe". 通常，您会看到用于此目的的特殊“结果”类。这真的没关系 - 我可以使用任何具有CustomerName字符串字段的类。

当我指定时.As<OrderVM>()——这就是我实际从一个Order类型转移到一个OrderVM类型的地方——并且该CustomerName字段随之而来，因为我们为它打开了字段存储。

TL;博士

RavenDB 有很多选择。尝试找出适合您需求的方法。正确的文档设计和谨慎使用索引相关文档将LoadDocument()最常消除对索引转换的需要。

于 2013-02-18T23:05:59.680 回答