RavenDB针对索引的惰性搜索返回未初始化的统计数据

我正在尝试对raven db运行惰性查询，并获取总匹配结果的计数。我发现，当我对一个静态索引进行查询时，当查询具体化时，惰性搜索不会初始化统计数据，但在其他情况下，它会正常返回。 下面是证明这种行为的测试

[TestFixture]
public class CanSearchLazily
{
    private const int ServerPort = 8085;
    private readonly string _serverAddress = @"http://localhost:{0}".For(ServerPort);

    [Test]
    public void CanGetTotalResultsFromStatisticsOnLazySearchAgainstDynamicIndex()
    {
        CanGetTotalResultsFromStatisticsOnLazySearchAgainstAnIndex();
    }

    [Test]
    public void CanGetTotalResultsFromStatisticsOnLazySearchAgainstStaticIndex()
    {
        CanGetTotalResultsFromStatisticsOnLazySearchAgainstAnIndex("UserByFirstName");
    }

    private void CanGetTotalResultsFromStatisticsOnLazySearchAgainstAnIndex(string indexName = "")
    {
        BuilderSetup.DisablePropertyNamingFor<User, string>(x => x.Id);

        var users = Builder<User>.CreateListOfSize(2000).All()
            .With(x => x.FirstName = GetRandom.FirstName())
            .With(x => x.LastName = GetRandom.LastName())
            .Build();

        using (GetNewServer())
        using (var store = new DocumentStore { Url = _serverAddress }.Initialize())
        {
            using (var session = store.OpenSession())
            {
                users.ForEach(session.Store);
                session.SaveChanges();
                IndexCreation.CreateIndexes(typeof(UserByFirstName).Assembly, store);
                session.Query<User, UserByFirstName>().Customize(x => x.WaitForNonStaleResults()).ToList();
            }

            using (var session = store.OpenSession())
            {
                var names = session.Query<User>().Select(u => u.FirstName).Distinct().Take(15).ToList();

                RavenQueryStatistics stats;

                var query = string.IsNullOrEmpty(indexName) 
                        ? session.Query<User>().Statistics(out stats).Where(x => x.FirstName.In(names))
                        : session.Query<User>(indexName).Statistics(out stats).Where(x => x.FirstName.In(names));

                var results = query.Take(8).Lazily();

                Assert.AreEqual(8, results.Value.ToList().Count);
                Assert.AreEqual(DateTime.Now.Year, stats.IndexTimestamp.Year, "the index should have the current year on its timestamp");
                Assert.IsTrue(stats.TotalResults > 0, "The stats should return total results");
            }
        }
    }

    protected RavenDbServer GetNewServer(bool initializeDocumentsByEntitiyName = true)
    {
        var ravenConfiguration = new RavenConfiguration
        {
            Port = ServerPort,
            RunInMemory = true,
            DataDirectory = "Data",
            AnonymousUserAccessMode = AnonymousUserAccessMode.All
        };

        if (ravenConfiguration.RunInMemory == false)
            IOExtensions.DeleteDirectory(ravenConfiguration.DataDirectory);

        var ravenDbServer = new RavenDbServer(ravenConfiguration);

        if (initializeDocumentsByEntitiyName)
        {
            using (var documentStore = new DocumentStore
            {
                Url = _serverAddress
            }.Initialize())
            {
                new RavenDocumentsByEntityName().Execute(documentStore);
            }
        }

        return ravenDbServer;
    }
}

[Serializable]
public class User
{
    public string Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class UserByFirstName : AbstractIndexCreationTask<User>
{
    public UserByFirstName()
    {
        Map = users => from user in users
                       select new {user.FirstName};
    }
}

[TestFixture]
公共类可以懒散地搜索
{
private const int ServerPort=8085；
专用只读字符串\u服务器地址=@”http://localhost:{0}.For（服务器端口）；
[测试]
公共无效数据只能从统计数据中获取总结果
{
仅将统计结果的总结果存储在Ashargain指数（）中；
}
[测试]
public void CangetTotalResults from StatisticsOnlazySearchaGaInStaticIndex（）
{
仅通过统计数据将总结果存入ArchaGain索引（“UserByFirstName”）；
}
private void可以从StatisticsOnlazySarchaGaInStanidex（string indexName=“”）获取总结果
{
disablePropertyNamegfor（x=>x.Id）；
var users=Builder.CreateListOfSize（2000）.All（）
.With（x=>x.FirstName=GetRandom.FirstName（））
.With（x=>x.LastName=GetRandom.LastName（））
.Build（）；
使用（GetNewServer（））
使用（var store=newdocumentstore{Url=_serverAddress}.Initialize（））
{
使用（var session=store.OpenSession（））
{
users.ForEach（session.Store）；
session.SaveChanges（）；
CreateIndexes（typeof（UserByFirstName）.Assembly，store）；
session.Query（）.Customize（x=>x.waitForNonSaleResults（））.ToList（）；
}
使用（var session=store.OpenSession（））
{
var name=session.Query（）.Select（u=>u.FirstName）.Distinct（）.Take（15.ToList（）；
拉文奎尔统计数据；
var query=string.IsNullOrEmpty（indexName）
？session.Query（）.Statistics（out stats）.Where（x=>x.FirstName.In（name））
：session.Query（indexName）.Statistics（out stats）.Where（x=>x.FirstName.In（names））；
var results=query.Take（8.lazly（）；
aresequal（8，results.Value.ToList（）.Count）；
AreEqual（DateTime.Now.Year，stats.IndexTimestamp.Year，“索引的时间戳上应该有当前年份”）；
IsTrue（stats.TotalResults>0，“统计数据应返回总结果”）；
}
}
}
受保护的RavenDbServer GetNewServer（bool InitializedDocumentsByEntityName=true）
{
var ravenConfiguration=新的ravenConfiguration
{
端口=服务器端口，
RunInMemory=true，
DataDirectory=“Data”，
AnonymousUserAccessMode=AnonymousUserAccessMode.All
};
if（ravenConfiguration.RunInMemory==false）
DeleteDirectory（ravenConfiguration.DataDirectory）；
var ravenDbServer=新的ravenDbServer（ravenConfiguration）；
if（初始化文档的ByEntityName）
{
使用（var documentStore=newdocumentstore）
{
Url=\u服务器地址
}.Initialize（））
{
新建RavenDocumentsByEntityName（）.Execute（documentStore）；
}
}
返回ravenDbServer；
}
}
[可序列化]
公共类用户
{
公共字符串Id{get；set；}
公共字符串名{get；set；}
公共字符串LastName{get；set；}
}
公共类UserByFirstName:AbstractIndexCreationTask
{
公共UserByFirstName（）
{
Map=users=>来自用户中的用户
选择新建{user.FirstName}；
}
}

您使用的是什么版本？我们刚刚在最新版本上进行了测试，效果很好