使用 nosql 性能注意事项的事件存储

Question

这可能更像是一个一般的NOSQL基础设施问题。

使用事件溯源系统，我将事件文档保存到 ravendb。

在我的域模型中，有多种类型的事件，下面是一个基本示例：

public abstract class Event
{
    public Guid AggregateId { get; set; }
    public Event(Guid aggregateId)
    {
        AggregateId = aggregateId;
    }
}
public class NewPersonEvent : Event
{
    public string Name { get; set; }
    public NewPersonEvent(Guid id, string name) : Base(id)
    {
        Name = name;
    }
}
public class NewOrderEvent : Event
{
    public DateTime OrderDate { get; set; }
    public double OrderCost { get; set;}

    public NewOrderEvent(Guid id, DateTime date, double cost) : Base(id)
    {
        OrderDate = date;
        OrderCost = cost;
    }
}

无论事件来自哪种类型的聚合，事件都将作为事件文档持久化。

这是在 ravendb 中对所有事件使用一种文档类型的最佳方法吗？或者按聚合对文档类型进行分组是否有任何好处

而不是只有"事件"文档，而是拥有"PersonEvent"文档和"OrderEvent"文档。

这两种方法的优缺点是什么，特别是是否存在任何性能问题？

Answer 1

您是否覆盖事件的默认标记名称为...

docStore.Conventions.FindTypeTagName = type => typeof(Event).IsAssignableFrom(type) ? DocumentConvention.DefaultTypeTagName(typeof(Event)) : DocumentConvention.DefaultTypeTagName(type);

然后，每当您对Event执行查询时，它就会起作用并检索所有事件。 session.Query<Event>()

如果是这样，你可以搬起石头砸自己的脚，因为如果你只想要事件的子集并且你这样做session.Query<NewPersonEvent>()它将检索所有事件，因为你一开始就覆盖了标签约定。您仍然可以以另一种方式执行此操作，但它不会那么简单（例如，为事件类型设置一个枚举并按枚举进行过滤）。

我会投票不覆盖默认的 RavenDB 行为，将不同的事件类型保留为它们自己的文档集合，并简单地使用多映射索引。

Raven 文档指出，静态索引优先于动态索引，因此它不应该成为性能问题。 文档：

如果您不弄乱标记约定，但可以为事件的子集创建更多索引，创建 map/reduce 索引以聚合每个事件类型的计数等等。

该索引将是一个多地图索引，您可以选择 2 种风格。

选项 1

    public class Events_All : AbstractMultiMapIndexCreationTask
    {
        public Events_All()
        {
            AddMap<NewPersonEvent>(newPersonEvents =>
                from newPersonEvent in newPersonEvents
                select new
                {
                    Id   = newPersonEvent.AggregateId
                });
            AddMap<NewOrderEvent>(newOrderEvents =>
                from newOrderEvent in newOrderEvents
                select new
                {
                    Id   = newOrderEvent.AggregateId
                });
        }
    }

选项 2（反射）

public class Events_All2 : AbstractMultiMapIndexCreationTask
{
    public Events_All2()
    {
        AddMapForAll<Event>(events =>
            from @event in events
            select new
            {
                Id   = @event.AggregateId
            });
    }
}

下面是使用 RavenDB.Tests.Helpers 和 Shouldly NuGet 包的示例测试。它使用第一个示例索引，但您也可以修改它以使用第二个示例索引。

    public class MultimapIndexTest : RavenTestBase
    {
        private readonly Random _random = new Random();
        [Fact]
        public void GetAll_HasBoth_Success()
        {
            //Arrange
            const string personName = "Jimmy";
            double randomCost = _random.Next();
            var event1 = new NewPersonEvent(Guid.NewGuid(), personName);
            var event2 = new NewOrderEvent(Guid.NewGuid(), DateTime.Now, randomCost);
            using (var docStore = NewDocumentStore())
            {
                docStore.ExecuteIndex(new Events_All());
                using (var sesion = docStore.OpenSession())
                {
                    sesion.Store(event1);
                    sesion.Store(event2);
                    sesion.SaveChanges();
                }
                docStore.WaitForStaleIndexesToComplete();
                //Act
                var events = GetAll(docStore).ToList();
                //Assert
                events.ShouldNotBeEmpty();
                events.Count().ShouldBe(2);
                var newPersonEvent = events.FirstOrDefault(x => x is NewPersonEvent) as NewPersonEvent;
                newPersonEvent.ShouldNotBe(null);
                newPersonEvent.Name.ShouldBe(personName);
                var newOrderEvent = events.FirstOrDefault(x => x is NewOrderEvent) as NewOrderEvent;
                newOrderEvent.ShouldNotBe(null);
                newOrderEvent.OrderCost.ShouldBe(randomCost);
            }
        }
        private IEnumerable<Event> GetAll(DocumentStore docStore)
        {
            using (var session = docStore.OpenSession())
            {
                return session.Query<Event, Events_All>();
            }
        }
    }