private Dictionary <string, FacetResult> ProcessResults(QueryResult queryResult, DocumentConventions conventions)
{
InvokeAfterQueryExecuted(queryResult);
var results = new Dictionary <string, FacetResult>();
foreach (BlittableJsonReaderObject result in queryResult.Results)
{
var facetResult = (FacetResult)EntityToBlittable.ConvertToEntity(typeof(FacetResult), "facet/result", result, conventions);
results[facetResult.Name] = facetResult;
}
QueryOperation.EnsureIsAcceptable(queryResult, _query.WaitForNonStaleResults, _duration, _session);
return(results);
}
public async Task Huge_document_hints_are_stored_and_can_be_read()
{
using (var store = GetDocumentStore())
{
var database = await GetDatabase(store.Database);
// this tests write to storage
database.HugeDocuments.AddIfDocIsHuge("orders/1-A", 10 * 1024 * 1024);
// this tests merge with existing item
database.HugeDocuments.AddIfDocIsHuge("orders/2-A", 20 * 1024 * 1024);
database.HugeDocuments.AddIfDocIsHuge("orders/3-A", 30 * 1024 * 1024);
database.HugeDocuments.AddIfDocIsHuge("orders/4-A", 40 * 1024 * 1024);
database.HugeDocuments.UpdateHugeDocuments(null);
Assert.True(database.ConfigurationStorage.NotificationsStorage.GetPerformanceHintCount() > 0);
// now read directly from storage and verify
using (database.ConfigurationStorage.NotificationsStorage.Read(HugeDocuments.HugeDocumentsId, out var ntv))
{
if (ntv == null || ntv.Json.TryGet(nameof(PerformanceHint.Details), out BlittableJsonReaderObject detailsJson) == false || detailsJson == null)
{
Assert.False(true, "Unable to read stored notification");
}
else
{
HugeDocumentsDetails details = (HugeDocumentsDetails)EntityToBlittable.ConvertToEntity(
typeof(HugeDocumentsDetails),
HugeDocuments.HugeDocumentsId,
detailsJson,
DocumentConventions.Default);
Assert.NotNull(details);
Assert.Equal(4, details.HugeDocuments.Count);
var ids = details.HugeDocuments.Values.Select(x => x.Id).ToList();
Assert.Contains("orders/1-A", ids);
Assert.Contains("orders/2-A", ids);
Assert.Contains("orders/3-A", ids);
Assert.Contains("orders/4-A", ids);
}
}
}
}
public async Task ReadDocWithCompressedStringFromOneContextAndWriteToAnother()
{
using (var documentStore = this.GetDocumentStore())
{
Server.ServerStore.Observer.Suspended = true;
var originalDoc = new Doc
{
Id = "doc/1",
StrVal = new string(Enumerable.Repeat('.', 129).ToArray()),
LongByteArray = Enumerable.Repeat((byte)2, 1024).ToArray()
};
using (var session = documentStore.OpenAsyncSession())
{
await session.StoreAsync(originalDoc);
await session.SaveChangesAsync();
}
var database = await Server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(documentStore.Database);
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
{
var doc = database.DocumentsStorage.Get(context, "doc/1");
MemoryStream ms = new MemoryStream();
using (var newContext = JsonOperationContext.ShortTermSingleUse())
using (var writer = new BlittableJsonTextWriter(newContext, ms))
{
writer.WriteDocument(newContext, doc, metadataOnly: false);
writer.Flush();
var bjro = GetReaderFromMemoryStream(ms, context);
var desereializedDoc = (Doc)EntityToBlittable.ConvertToEntity(typeof(Doc), null, bjro, DocumentConventions.Default);
Assert.Equal(originalDoc.StrVal, desereializedDoc.StrVal);
Assert.Equal(originalDoc.LongByteArray, originalDoc.LongByteArray);
}
}
}
}
public static CompareExchangeResult <T> ParseFromBlittable(BlittableJsonReaderObject response, DocumentConventions conventions)
{
if (response.TryGet(nameof(Index), out long index) == false)
{
throw new InvalidDataException("Response is invalid. Index is missing.");
}
response.TryGet(nameof(Successful), out bool successful);
response.TryGet(nameof(Value), out BlittableJsonReaderObject raw);
T result;
object val = null;
raw?.TryGet("Object", out val);
if (val == null)
{
return(new CompareExchangeResult <T>
{
Index = index,
Value = default(T),
Successful = successful
});
}
if (val is BlittableJsonReaderObject obj)
{
result = (T)EntityToBlittable.ConvertToEntity(typeof(T), "cluster-value", obj, conventions);
}
else
{
raw.TryGet("Object", out result);
}
return(new CompareExchangeResult <T>
{
Index = index,
Value = result,
Successful = successful
});
}
public override void SetResponse(BlittableJsonReaderObject response, bool fromCache)
{
if (response.TryGet(nameof(RawClusterValueResult.Index), out long index) == false)
{
ThrowInvalidResponse();
}
response.TryGet(nameof(RawClusterValueResult.Value), out BlittableJsonReaderObject raw);
T result;
object val = null;
raw?.TryGet("Object", out val);
if (val == null)
{
Result = new ClusterValueResult <T>
{
Index = index,
Value = default(T)
};
return;
}
if (val is BlittableJsonReaderObject obj)
{
result = (T)EntityToBlittable.ConvertToEntity(typeof(T), "cluster-value", obj, _conventions);
}
else
{
raw.TryGet("Object", out result);
}
Result = new ClusterValueResult <T>
{
Index = index,
Value = result
};
}
public async Task SubscriptionShouldRespectDocumentsWithCompressedData()
{
using (var documentStore = this.GetDocumentStore())
{
Server.ServerStore.Observer.Suspended = true;
var originalDoc = new Doc
{
Id = "doc/1",
StrVal = new string(Enumerable.Repeat('.', 129).ToArray()),
LongByteArray = Enumerable.Repeat((byte)2, 1024).ToArray()
};
using (var session = documentStore.OpenAsyncSession())
{
await session.StoreAsync(originalDoc);
await session.SaveChangesAsync();
}
var database = await Server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(documentStore.Database);
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
{
var doc = database.DocumentsStorage.Get(context, "doc/1");
MemoryStream ms = new MemoryStream();
using (var newContext = JsonOperationContext.ShortTermSingleUse())
using (var writer = new BlittableJsonTextWriter(newContext, ms))
{
writer.WriteDocument(newContext, doc, metadataOnly: false);
writer.Flush();
var bjro = GetReaderFromMemoryStream(ms, context);
var desereializedDoc = (Doc)EntityToBlittable.ConvertToEntity(typeof(Doc), null, bjro, DocumentConventions.Default);
Assert.Equal(originalDoc.StrVal, desereializedDoc.StrVal);
Assert.Equal(originalDoc.LongByteArray, originalDoc.LongByteArray);
}
}
var subscriptionCreationParams = new SubscriptionCreationOptions
{
Query = "from Docs",
};
var subsId = await documentStore.Subscriptions.CreateAsync(subscriptionCreationParams).ConfigureAwait(false);
var amre = new AsyncManualResetEvent();
using (var subscription = documentStore.Subscriptions.GetSubscriptionWorker <Doc>(new SubscriptionWorkerOptions(subsId)))
{
var t = subscription.Run(batch =>
{
var receivedDoc = batch.Items.First().Result;
Assert.Equal(originalDoc.LongByteArray, receivedDoc.LongByteArray);
Assert.Equal(originalDoc.StrVal, receivedDoc.StrVal);
amre.Set();
});
try
{
Assert.True(await amre.WaitAsync(TimeSpan.FromSeconds(60)));
}
catch
{
if (t.IsFaulted)
{
t.Wait();
}
throw;
}
}
}
}
public static Dictionary <string, CompareExchangeValue <T> > GetValues(BlittableJsonReaderObject response, DocumentConventions conventions)
{
if (response.TryGet("Results", out BlittableJsonReaderArray items) == false)
{
throw new InvalidDataException("Response is invalid. Results is missing.");
}
var results = new Dictionary <string, CompareExchangeValue <T> >();
foreach (BlittableJsonReaderObject item in items)
{
if (item == null)
{
throw new InvalidDataException("Response is invalid. Item is null.");
}
if (item.TryGet("Key", out string key) == false)
{
throw new InvalidDataException("Response is invalid. Key is missing.");
}
if (item.TryGet("Index", out long index) == false)
{
throw new InvalidDataException("Response is invalid. Index is missing.");
}
if (item.TryGet("Value", out BlittableJsonReaderObject raw) == false)
{
throw new InvalidDataException("Response is invalid. Value is missing.");
}
if (typeof(T).GetTypeInfo().IsPrimitive || typeof(T) == typeof(string))
{
// simple
T value = default(T);
raw?.TryGet("Object", out value);
results[key] = new CompareExchangeValue <T>(key, index, value);
}
else
{
BlittableJsonReaderObject val = null;
raw?.TryGet("Object", out val);
if (val == null)
{
results[key] = new CompareExchangeValue <T>(key, index, default(T));
}
else
{
T convereted;
if (typeof(T) == typeof(BlittableJsonReaderObject))
{
convereted = (T)(object)val;
}
else
{
convereted = (T)EntityToBlittable.ConvertToEntity(typeof(T), null, val, conventions);
}
results[key] = new CompareExchangeValue <T>(key, index, convereted);
}
}
}
return(results);
}
public void CanDoFacetQueryWithAliasOnFullRange_WhenAliasIsTheSameAsOneOfTheIndexFields()
{
using (var store = GetDocumentStore())
{
new Orders_Totals().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new Order
{
Company = "C1",
Employee = "E1",
Lines = new List <OrderLine>
{
new OrderLine
{
Quantity = 1,
PricePerUnit = 10,
Discount = 0
},
new OrderLine
{
Quantity = 3,
PricePerUnit = 30,
Discount = 0
}
}
});
session.Store(new Order
{
Company = "C2",
Employee = "E2",
Lines = new List <OrderLine>
{
new OrderLine
{
Quantity = 2,
PricePerUnit = 20,
Discount = 0
},
new OrderLine
{
Quantity = 4,
PricePerUnit = 40,
Discount = 0
}
}
});
session.Store(new Order
{
Company = "C3",
Employee = "E3",
Lines = new List <OrderLine>
{
new OrderLine
{
Quantity = 3,
PricePerUnit = 30,
Discount = 0
},
new OrderLine
{
Quantity = 5,
PricePerUnit = 50,
Discount = 0
}
}
});
session.SaveChanges();
}
WaitForIndexing(store);
using (var commands = store.Commands())
{
var result = commands.Query(new Raven.Client.Documents.Queries.IndexQuery
{
Query = @"
from index 'Orders/Totals'
where Total < 1000
select facet(sum(Total)) as Total"
});
var facetResult = (FacetResult)EntityToBlittable.ConvertToEntity(typeof(FacetResult), "facet/result", (BlittableJsonReaderObject)result.Results[0], store.Conventions);
Assert.Equal("Total", facetResult.Name);
Assert.Equal(1, facetResult.Values.Count);
Assert.Equal(Constants.Documents.Querying.Facet.AllResults, facetResult.Values[0].Range);
Assert.Equal(3, facetResult.Values[0].Count);
}
}
}
private void NotifySubscribers(BlittableJsonReaderObject curDoc, out long lastReceivedEtag)
{
BlittableJsonReaderObject metadata;
string id;
if (curDoc.TryGet(Constants.Metadata.Key, out metadata) == false)
{
throw new InvalidOperationException("Document must have a metadata");
}
if (metadata.TryGet(Constants.Metadata.Id, out id) == false)
{
throw new InvalidOperationException("Document must have an id");
}
if (metadata.TryGet(Constants.Metadata.Etag, out lastReceivedEtag) == false)
{
throw new InvalidOperationException("Document must have an ETag");
}
T instance;
if (typeof(T) == typeof(BlittableJsonReaderObject))
{
instance = (T)(object)curDoc;
}
else
{
instance = (T)EntityToBlittable.ConvertToEntity(typeof(T), id, curDoc, _conventions);
}
if (string.IsNullOrEmpty(id) == false)
{
_generateEntityIdOnTheClient.TrySetIdentity(instance, id);
}
foreach (var subscriber in _subscribers)
{
_proccessingCts.Token.ThrowIfCancellationRequested();
try
{
subscriber.OnNext(instance);
}
catch (Exception ex)
{
Logger.WarnException(
string.Format(
"Subscription #{0}. Subscriber threw an exception", _options.SubscriptionId), ex);
if (_options.IgnoreSubscribersErrors == false)
{
IsErroredBecauseOfSubscriber = true;
LastSubscriberException = ex;
try
{
subscriber.OnError(ex);
}
catch (Exception)
{
// can happen if a subscriber doesn't have an onError handler - just ignore it
}
break;
}
}
}
}