RavenDb学习（九）高级特性下半部分

.聚合缓存

RavenDb默认是缓存所有的请求url的，最大的缓存请求数默认是2048
documentStore.Conventions.ShouldCacheRequest = url => true;
documentStore.MaxNumberOfCachedRequests = ;

如果开启这个选项，RavenDb直接从缓存当中读取数据，而不是从服务端。

//关闭跟踪
documentStore.Conventions.ShouldAggressiveCacheTrackChanges = false;

)))
{
    var user = session.Load<User>("users/1");
}

)))
{
    var user = session.Load<User>("users/1");
}

//启动强制检查更新，在SaveChanges之后
documentStore.Conventions.ShouldSaveChangesForceAggresiveCacheCheck = true;

、客户端Listener
Document Conflict listeners (IDocumentConflictListener),
Document Conversion listeners (IDocumentConversionListener)
Document Delete listeners (IDocumentDeleteListener)
Document Query listeners (IDocumentQueryListener)
Document Store listeners (IDocumentStoreListener)
例子1：

public class TakeNewestConflictResolutionListener : IDocumentConflictListener
{
    public bool TryResolveConflict(string key, JsonDocument[] conflictedDocs, out JsonDocument resolvedDocument)
    {
        var maxDate = conflictedDocs.Max(x => x.LastModified);
        resolvedDocument = conflictedDocs.FirstOrDefault(x => x.LastModified == maxDate);

        return resolvedDocument != null;
    }
}

例子2:

public class Custom
{
    public string Id { get; set; }

    public string Name { get; set; }

    public string Value { get; set; }
}

public class MetadataToPropertyConversionListener : IDocumentConversionListener
{
    public void EntityToDocument(string key, object entity, RavenJObject document, RavenJObject metadata)
    {
        if (entity is Custom == false)
            return;
        document.Remove("Value");
    }

    public void DocumentToEntity(string key, object entity, RavenJObject document, RavenJObject metadata)
    {
        if (entity is Custom == false)
            return;
        ((Custom)entity).Value = metadata.Value<string>("Raven-Document-Revision");
    }
}

例子3：

public class FailDelete : IDocumentDeleteListener
{
    public void BeforeDelete(string key, object entityInstance, RavenJObject metadata)
    {
        throw new NotSupportedException();
    }
}

例子4：

public class NonStaleQueryListener : IDocumentQueryListener
{
    public void BeforeQueryExecuted(IDocumentQueryCustomization customization)
    {
        customization.WaitForNonStaleResults();
    }
}

例子5：

public class FilterForbiddenKeysDocumentListener : IDocumentStoreListener
{
    private readonly IList<string> forbiddenKeys = new List<string> { "system" };

    public bool BeforeStore(string key, object entityInstance, RavenJObject metadata, RavenJObject original)
    {
        return this.forbiddenKeys.Any(x => x.Equals(key, StringComparison.InvariantCultureIgnoreCase)) == false;
    }

    public void AfterStore(string key, object entityInstance, RavenJObject metadata)
    {
    }
}

、批量插入

//批量插入代码示例
using (var bulkInsert = store.BulkInsert())
{
    ; i <  * ; i++)
    {
        bulkInsert.Store(new User
            {
                Name = "Users #" + i
            });
    }
}

//批量插入接口原型
public interface IDocumentStore
{
    BulkInsertOperation BulkInsert(string database = null, BulkInsertOptions options = null);
}
//批量插入选项原型
public class BulkInsertOptions
{
    public bool CheckForUpdates { get; set; }

    public bool CheckReferencesInIndexes { get; set; }

    public int BatchSize { get; set; }
}
//批量插入操作原型
public class BulkInsertOperation
{
    public delegate void BeforeEntityInsert(string id, RavenJObject data, RavenJObject metadata);

    public event BeforeEntityInsert OnBeforeEntityInsert = delegate { };

    public event Action<string> Report { ... }

    public void Store(object entity) { ... }

    public void Store(object entity, string id) { ... }
}

、流式查询

默认的分页查询的，但是有时候，我们需要一次性查询，RavenDb提供了一种流式查询的方式

//正常查询
var query = session.Query<User>("Users/ByActive").Where(x => x.Active);
using (var enumerator = session.Advanced.Stream(query))
{
    while (enumerator.MoveNext())
    {
        User activeUser = enumerator.Current.Document;
    }
}
//lucene查询
var luceneQuery = session.Advanced.LuceneQuery<User>("Users/ByActive").Where("Active:true");
using (var enumerator = session.Advanced.Stream(luceneQuery))
{
    while (enumerator.MoveNext())
    {
        User activeUser = enumerator.Current.Document;
    }
}

//接口原型
QueryHeaderInformation queryHeaderInformation;
session.Advanced.Stream(query, out queryHeaderInformation);

public class QueryHeaderInformation
{
    public string Index { get; set; }
    public bool IsStable { get; set; }
    public DateTime IndexTimestamp { get; set; }
    public int TotalResults { get; set; }
    public Etag ResultEtag { get; set; }
    public Etag IndexEtag { get; set; }
}

//分页
using (var enumerator = session.Advanced.Stream<User>(fromEtag: Etag.Empty,
                                                      start: , pageSize: int.MaxValue))
{
    while (enumerator.MoveNext())
    {
        User activeUser = enumerator.Current.Document;
    }
}

//
using (var enumerator = session.Advanced.Stream<User>(startsWith: "users/",
                                                      matches: "*Ra?en",
                                                      start: , pageSize: int.MaxValue))
{
    while (enumerator.MoveNext())
    {
        User activeUser = enumerator.Current.Document;
    }
}

//异步版本
using (var asyncSession = store.OpenAsyncSession())
{
    var query = asyncSession.Query<User>("Users/ByActive").Where(x => x.Active);

    using (var enumerator = await asyncSession.Advanced.StreamAsync(query))
    {
        while (await enumerator.MoveNextAsync())
        {
            User activeUser = enumerator.Current.Document;
        }
    }

    using (var enumerator = await asyncSession.Advanced.StreamAsync<User>(Etag.Empty))
    {
        while (await enumerator.MoveNextAsync())
        {
            User activeUser = enumerator.Current.Document;
        }
    }
}