Question

我有一个多地图索引，需要在Reduce结果中获得最大日期。

当我尝试：

Reduce = results => from result in results
                    group result by result.Id into g
                    select new
                    {
                        Id = g.Key,
                        AccountId = g.Select(x => x.AccountId).Where(x => x != null).FirstOrDefault(),
                        Hostnames = g.SelectMany(x => x.Hostnames),
                        NextRenewalDate = g.Select(x => x.NextRenewalDate).Max(),
                        SubscriptionCount = g.Sum(x => x.SubscriptionCount)
                    };

NextRenewalDate始终为空。

但是，我可以这样做：

NextRenewalDate = g.Select(x => x.NextRenewalDate).FirstOrDefault,

我确实得到了结果。

我想知道这是否是由于RavenDB如何解释索引中的日期。我的Reduce Result类如下：

public class ReduceResult
{
    public string Id { get; set; }
    public string AccountId { get; set; }
    public string[] Hostnames { get; set; }
    public DateTime NextRenewalDate { get; set; }
    public int SubscriptionCount { get; set; }
}

更新

我已经能够使索引工作，但前提是我将DateTime转换为ISO8601字符串。我的完整索引如下：

public class Account_Sites : AbstractMultiMapIndexCreationTask<Account_Sites.ReduceResult>
{
    public Account_Sites()
    {
        AddMap<CMS.Domain.Site>(sites => from site in sites
                                         from url in site.Urls
                                         select new
                                         {
                                             Id = site.Id,
                                             AccountId = (string)null,
                                             Hostnames = new[] { url.Hostname },
                                             SubscriptionDueDate = DateTime.MinValue,
                                             SubscriptionStartDate = DateTime.MinValue
                                         });

        AddMap<Domain.Account>(accounts => from account in accounts
                                           from siteId in account.Sites
                                           from subscription in account.Subscriptions
                                           where subscription != null
                                           select new
                                           {
                                               Id = siteId,
                                               AccountId = account.Id,
                                               Hostnames = new string[0],
                                               SubscriptionDueDate = subscription.NextRenewalDate,
                                               SubscriptionStartDate = subscription.StartDate
                                           });

        Reduce = results => from result in results
                            group result by result.Id into g
                            select new
                            {
                                Id = g.Key,
                                AccountId = g.Select(x => x.AccountId).Where(x => x != null).FirstOrDefault(),
                                Hostnames = g.SelectMany(x => x.Hostnames),
                                SubscriptionDueDate = g.Max(x => x.SubscriptionDueDate.ToString("o")), // ISO 8601 format e.g. 2012-10-22T12:51:03.0263843+00:00
                                SubscriptionStartDate = g.Max(x => x.SubscriptionStartDate.ToString("o"))
                            };
    }

    public class ReduceResult
    {
        public string Id { get; set; }
        public string AccountId { get; set; }
        public string[] Hostnames { get; set; }
        public DateTime SubscriptionDueDate { get; set; }
        public DateTime SubscriptionStartDate { get; set; }
    }
}

更新2

我在下面发布了一个完整的失败测试。丹尼尔的测试确实有效，但以下失败了。但是，将TestSubscription.EndDate更改为DateTime.Now（而不是UtcNow）确实有效。这是使用构建 1.2.2103-Unstable 。

public class TestAccount
{
    public string Id { get; set; }
    public List<string> Sites { get; set; }
    public List<TestSubscription> Subscriptions { get; set; }

    public TestAccount()
    {
        Sites = new List<string>();
        Subscriptions = new List<TestSubscription>();
    }
}

public class TestSubscription
{
    public DateTime EndDate { get; set; }
}

public class TestSite
{
    public string Id { get; set; }
    public string Hostname { get; set; }
}

public class SitesWithSubscriptions : AbstractMultiMapIndexCreationTask<SitesWithSubscriptions.Result>
{
    public SitesWithSubscriptions()
    {
        AddMap<TestSite>(sites => from site in sites
                                  select new
                                  {
                                      SiteId = site.Id,
                                      Hostname = site.Hostname,
                                      SubscriptionEndDate = DateTime.MinValue
                                  });

        AddMap<TestAccount>(accounts => from account in accounts
                                        from siteId in account.Sites
                                        from subscription in account.Subscriptions
                                        select new
                                        {
                                            SiteId = siteId,
                                            Hostname = (string)null,
                                            SubscriptionEndDate = subscription.EndDate
                                        });

        Reduce = results => from result in results
                            group result by result.SiteId into g
                            select new
                            {
                                SiteId = g.Key,
                                Hostname = g.Select(x => x.Hostname).Where(x => x != null).FirstOrDefault(),
                                SubscriptionEndDate = g.Max(x => x.SubscriptionEndDate)
                            };
    }

    public class Result
    {
        public string SiteId { get; set; }
        public string Hostname { get; set; }
        public DateTime SubscriptionEndDate { get; set; }
    }
}

    public class SitesSpecs : RavenSpecs
{
    static IEnumerable<SitesWithSubscriptions.Result> results;

    Establish ctx = () =>
    {
        using (var session = Store.OpenSession())
        {
            var site = new TestSite { Hostname = "www.dev.com" };
            session.Store(site);

            var account = new TestAccount();
            account.Subscriptions.Add(new TestSubscription { EndDate = DateTime.UtcNow });
            account.Sites.Add(site.Id);
            session.Store(account);

            session.SaveChanges();
        }           
    };

    Because of = () =>
    {
        using (var session = Store.OpenSession())
        {
            results = session.Query<SitesWithSubscriptions.Result, SitesWithSubscriptions>()
                .Customize(x => x.WaitForNonStaleResults())
                .ToList();
        }
    };

    It Should_return_sites_with_subscription_end_dates = ()
        =>
    {
        results.Count().ShouldEqual(1);
        results.First().SubscriptionEndDate.Date.ShouldEqual(DateTime.UtcNow.Date);
    };
}

Answer 1

这是一个快速的例子，展示了如何做到这一点：

更新：我编写了这段代码来验证RavenDB可以按照您的要求处理DateTime。您不需要将其转换为ISO中的字符串，...我在Build 960中尝试过它。如果它不适合您，请提供失败的测试并让我们知道您正在使用哪个版本。

public class Student
{
    public string Id { get; set; }
    public string Classroom { get; set; }
    public DateTime Birthday { get; set; }
}

public class LatestBirthdayInClassroom : AbstractIndexCreationTask<Student, LatestBirthdayInClassroom.Result>
{
    public class Result
    {
        public string Classroom { get; set; }
        public DateTime LatestBirthday { get; set; }
    }

    public LatestBirthdayInClassroom()
    {
        Map = students => from student in students
                       select new
                       {
                           Classroom = student.Classroom,
                           LatestBirthday = student.Birthday
                       };

        Reduce = results => from result in results
                            group result by result.Classroom into g
                            select new
                            {
                                Classroom = g.Key,
                                LatestBirthday = g.Select(x => x.LatestBirthday).Max()
                            };
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var store = new EmbeddableDocumentStore
        {
            RunInMemory = true
        }.Initialize())
        {
            using (var session = store.OpenSession())
            {
                session.Store(new Student { Classroom = "A", Birthday = new DateTime(2012, 2, 1) });
                session.Store(new Student { Classroom = "A", Birthday = new DateTime(2012, 5, 1) });
                session.Store(new Student { Classroom = "A", Birthday = new DateTime(2012, 3, 1) });
                session.Store(new Student { Classroom = "B", Birthday = new DateTime(2012, 8, 1) });
                session.Store(new Student { Classroom = "B", Birthday = new DateTime(2012, 11, 1) });
                session.Store(new Student { Classroom = "B", Birthday = new DateTime(2012, 9, 1) });
                session.SaveChanges();
            }

            new LatestBirthdayInClassroom().Execute(store);

            // wait for indexing
            while (store.DatabaseCommands.GetStatistics().StaleIndexes.Length > 0)
            {
                Thread.Sleep(100);
            }

            using (var session = store.OpenSession())
            {
                var results = session.Query<LatestBirthdayInClassroom.Result, LatestBirthdayInClassroom>()
                    .ToList();
            }
        }
    }
}

Answer 2

这是RavenDB中的一个错误，已在build 2145中修复。http://issues.hibernatingrhinos.com/issue/RavenDB-718

的详细信息

在RavenDB中获取最小/最大日期会减少结果

更新2

2 个答案: