public void Can_update_alert()
{
using (var database = CreateDocumentDatabase())
using (var _ctx = DocumentsOperationContext.ShortTermSingleUse(database))
{
var alert1 = SampleAlert();
database.Alerts.AddAlert(alert1);
var alert2 = SampleAlert();
alert2.Message = "Updated message";
database.Alerts.AddAlert(alert2);
List <Alert> alerts;
using (var ms = new MemoryStream())
{
using (var writer = new BlittableJsonTextWriter(_ctx, ms))
{
database.Alerts.WriteAlerts(writer);
}
ms.Position = 0;
alerts = DeserializeAlerts(ms);
}
Assert.Equal(1, alerts.Count);
var loadedAlert = alerts[0];
Assert.Equal(alert2.Message, loadedAlert.Message);
}
}
public async Task Should_use_auto_index_even_if_idle_when_match_is_complete()
{
using (var database = CreateDocumentDatabase())
{
var autoIndex = await database.IndexStore.CreateIndex(new AutoMapIndexDefinition("Users", new[]
{
new AutoIndexField
{
Name = "FirstName",
},
new AutoIndexField
{
Name = "LastName",
}
}));
autoIndex.SetState(IndexState.Idle);
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
// it shouldn't throw
await database.QueryRunner.ExecuteQuery(new IndexQueryServerSide("from Users where LastName = 'Arek'"), context, null,
OperationCancelToken.None);
}
var sameIndex = database.IndexStore.GetIndex(autoIndex.Name);
Assert.Same(autoIndex, sameIndex);
Assert.Equal(IndexState.Normal, sameIndex.State);
}
}
public void PutAndGetDocumentById(string id)
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = id
}, id, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, id, null, doc);
}
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
var document = _documentDatabase.DocumentsStorage.Get(ctx, id);
Assert.NotNull(document);
Assert.Equal(1, document.Etag);
Assert.Equal(id, document.Id);
string name;
document.Data.TryGet("Name", out name);
Assert.Equal(id, name);
ctx.Transaction.Commit();
}
}
public void Update_should_retain_dismissed_date()
{
using (var database = CreateDocumentDatabase())
using (var _ctx = DocumentsOperationContext.ShortTermSingleUse(database))
{
var alert1 = SampleAlert();
alert1.DismissedUntil = new DateTime(2014, 10, 2);
database.Alerts.AddAlert(alert1);
var alert2 = SampleAlert();
database.Alerts.AddAlert(alert2);
List <Alert> alerts;
using (var ms = new MemoryStream())
{
using (var writer = new BlittableJsonTextWriter(_ctx, ms))
{
database.Alerts.WriteAlerts(writer);
}
ms.Position = 0;
alerts = DeserializeAlerts(ms);
}
Assert.Equal(1, alerts.Count);
var loadedAlert = alerts[0];
Assert.Equal(alert1.DismissedUntil, loadedAlert.DismissedUntil);
}
}
public async Task By_single_array_object()
{
using (var database = CreateDocumentDatabase())
{
using (var index = MapReduceIndex.CreateNew(new IndexDefinition()
{
Etag = 10,
Name = "Users_GroupByHobbies",
Maps = { @"from user in docs.Users select new {
user.Hobbies,
Count = 1
}" },
Reduce = @"from result in results group result by result.Hobbies into g select new {
Hobbies = g.Key,
Count = g.Sum(x => x.Count)
}",
Fields = new Dictionary <string, IndexFieldOptions>()
{
{ "Hobbies", new IndexFieldOptions()
{
Indexing = FieldIndexing.Search,
} }
}
}, database))
{
DocumentQueryResult queryResult;
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
Put_docs(context, database);
var batchStats = new IndexingRunStats();
var scope = new IndexingStatsScope(batchStats);
index.DoIndexingWork(scope, CancellationToken.None);
queryResult =
await index.Query(new IndexQueryServerSide($"FROM INDEX '{index.Name}'"), context, OperationCancelToken.None);
Assert.Equal(2, queryResult.Results.Count);
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
queryResult = await index.Query(new IndexQueryServerSide($"FROM INDEX '{index.Name}' WHERE Hobbies = 'music'"), context, OperationCancelToken.None);
var results = queryResult.Results;
Assert.Equal(1, results.Count);
Assert.Equal(1, queryResult.Results.Count);
Assert.Equal("music", ((BlittableJsonReaderArray)results[0].Data["Hobbies"])[0].ToString());
Assert.Equal("sport", ((BlittableJsonReaderArray)results[0].Data["Hobbies"])[1].ToString());
Assert.Equal(2L, results[0].Data["Count"]);
foreach (var document in results)
{
document.Data.Dispose();
}
}
}
}
}
public void Can_delete_alert()
{
using (var database = CreateDocumentDatabase())
using (var _ctx = DocumentsOperationContext.ShortTermSingleUse(database))
{
var alert1 = SampleAlert();
database.Alerts.AddAlert(alert1);
database.Alerts.DeleteAlert(alert1.Type, alert1.Key);
List <Alert> alerts;
using (var ms = new MemoryStream())
{
using (var writer = new BlittableJsonTextWriter(_ctx, ms))
{
database.Alerts.WriteAlerts(writer);
}
ms.Position = 0;
alerts = DeserializeAlerts(ms);
}
Assert.Equal(0, alerts.Count);
}
}
public void CanDelete(string id)
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = id
}, id, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, id, null, doc);
}
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
_documentDatabase.DocumentsStorage.Delete(ctx, id, null);
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
var document = _documentDatabase.DocumentsStorage.Get(ctx, id);
Assert.Null(document);
ctx.Transaction.Commit();
}
}
public static void CreateUsers(DocumentDatabase db, long numberOfUsers, params string[] locations)
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
using (var tx = context.OpenWriteTransaction())
{
for (int i = 0; i < numberOfUsers; i++)
{
using (var doc = context.ReadObject(new DynamicJsonValue
{
["Name"] = $"User-{i}",
["Location"] = locations[i % locations.Length],
["Age"] = 20 + i,
[Constants.Documents.Metadata.Key] = new DynamicJsonValue
{
[Constants.Documents.Metadata.Collection] = "Users"
}
}, $"users/{i}"))
{
db.DocumentsStorage.Put(context, $"users/{i}", null, doc);
}
}
tx.Commit();
}
}
}
public void CanQueryByGlobalEtag()
{
Initialize();
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "users/1", null, doc);
}
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Ayende",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/2", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "users/2", null, doc);
}
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Arava",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Dogs"
}
}, "pets/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "pets/1", null, doc);
}
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
var documents = _documentDatabase.DocumentsStorage.GetDocumentsFrom(ctx, 0, 0, 100).ToList();
Assert.Equal(3, documents.Count);
string name;
documents[0].Data.TryGet("Name", out name);
Assert.Equal("Oren", name);
documents[1].Data.TryGet("Name", out name);
Assert.Equal("Ayende", name);
documents[2].Data.TryGet("Name", out name);
Assert.Equal("Arava", name);
ctx.Transaction.Commit();
}
}
public void MaxNumberOfDocsToDeleteParameterShouldBeRespected()
{
using (var db = CreateDocumentDatabase())
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(db))
{
using (var tx = ctx.OpenWriteTransaction())
{
for (int i = 0; i < 10; i++)
{
using (var doc = CreateDocument(ctx, $"users/{i}",
new DynamicJsonValue
{
["Name"] = "John", [Constants.Documents.Metadata.Key] = new DynamicJsonValue {
[Constants.Documents.Metadata.Collection] = "Users"
}
}))
{
db.DocumentsStorage.Put(ctx, $"users/{i}", null, doc);
}
}
tx.Commit();
}
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(db))
{
using (var tx = ctx.OpenWriteTransaction())
{
// should delete all
var result = db.DocumentsStorage.DeleteDocumentsStartingWith(ctx, "users/");
Assert.Equal(10, result.Count);
// intentionally not committing
}
using (var tx = ctx.OpenWriteTransaction())
{
var result = db.DocumentsStorage.DeleteDocumentsStartingWith(ctx, "users/", maxDocsToDelete: 1);
Assert.Equal(1, result.Count);
result = db.DocumentsStorage.DeleteDocumentsStartingWith(ctx, "users/", maxDocsToDelete: 2);
Assert.Equal(2, result.Count);
result = db.DocumentsStorage.DeleteDocumentsStartingWith(ctx, "users/", maxDocsToDelete: 5);
Assert.Equal(5, result.Count);
result = db.DocumentsStorage.DeleteDocumentsStartingWith(ctx, "users/");
Assert.Equal(2, result.Count);
}
}
}
}
public async Task CanGroupByNestedFieldAndAggregateOnCollection()
{
using (var db = CreateDocumentDatabase())
using (var mri = AutoMapReduceIndex.CreateNew(1, new AutoMapReduceIndexDefinition(
new [] { "Orders" },
new []
{
new IndexField
{
Name = "Lines,Quantity",
MapReduceOperation = FieldMapReduceOperation.Sum,
Storage = FieldStorage.Yes
},
new IndexField
{
Name = "Lines,Price",
MapReduceOperation = FieldMapReduceOperation.Sum,
Storage = FieldStorage.Yes
}
},
new []
{
new IndexField
{
Name = "ShipTo.Country",
Storage = FieldStorage.Yes
},
}), db))
{
CreateOrders(db, 5, new[] { "Poland", "Israel" });
mri.DoIndexingWork(new IndexingStatsScope(new IndexingRunStats()), CancellationToken.None);
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
var queryResult = await mri.Query(new IndexQueryServerSide()
{
Query = "ShipTo_Country:Poland"
}, context, OperationCancelToken.None);
Assert.Equal(1, queryResult.Results.Count);
var result = queryResult.Results[0].Data;
string location;
Assert.True(result.TryGet("ShipTo.Country", out location));
Assert.Equal("Poland", location);
var price = result["Lines,Price"] as LazyDoubleValue;
Assert.NotNull(price);
Assert.Equal(63.6, price, 1);
var quantity = result["Lines,Quantity"];
Assert.Equal(9L, quantity);
}
}
}
public void CanQueryByPrefix()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["Raven-Entity-Name"] = "Users"
}
}, "users/10", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "users/10", null, doc);
}
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Ayende",
["@metadata"] = new DynamicJsonValue
{
["Raven-Entity-Name"] = "Users"
}
}, "users/02", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "users/02", null, doc);
}
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Arava",
["@metadata"] = new DynamicJsonValue
{
["Raven-Entity-Name"] = "Dogs"
}
}, "pets/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
_documentDatabase.DocumentsStorage.Put(ctx, "pets/1", null, doc);
}
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
var documents = _documentDatabase.DocumentsStorage.GetDocumentsStartingWith(ctx, "users/", null, null, 0, 100).ToList();
Assert.Equal(2, documents.Count);
string name;
documents[0].Data.TryGet("Name", out name);
Assert.Equal("Ayende", name);
documents[1].Data.TryGet("Name", out name);
Assert.Equal("Oren", name);
ctx.Transaction.Commit();
}
}
public async Task By_single_complex_object()
{
using (var database = CreateDocumentDatabase())
{
using (var index = MapReduceIndex.CreateNew(1, new IndexDefinition()
{
Name = "Users_ByCount_GroupByLocation",
Maps = { @"from user in docs.Users select new {
user.Location,
Count = 1
}" },
Reduce = @"from result in results group result by result.Location into g select new {
Location = g.Key,
Count = g.Sum(x => x.Count)
}",
Fields = new Dictionary <string, IndexFieldOptions>()
{
{ "Location", new IndexFieldOptions()
{
Indexing = FieldIndexing.Analyzed,
} }
}
}, database))
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
Put_docs(context, database);
var batchStats = new IndexingRunStats();
var scope = new IndexingStatsScope(batchStats);
index.DoIndexingWork(scope, CancellationToken.None);
var queryResult = await index.Query(new IndexQueryServerSide(), context, OperationCancelToken.None);
Assert.Equal(2, queryResult.Results.Count);
context.ResetAndRenew();
queryResult = await index.Query(new IndexQueryServerSide()
{
Query = @"Location:Poland"
}, context, OperationCancelToken.None);
var results = queryResult.Results;
Assert.Equal(1, results.Count);
Assert.Equal(1, queryResult.Results.Count);
Assert.Equal(@"{""Country"":""Poland"",""State"":""Pomerania""}", results[0].Data["Location"].ToString());
Assert.Equal(2L, results[0].Data["Count"]);
}
}
}
}
public void WillVerifyEtags_OnDeleteNotThere()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
Assert.Throws <ConcurrencyException>(() => _documentDatabase.DocumentsStorage.Delete(ctx, "users/1", 3));
ctx.Transaction.Commit();
}
}
public void GetSliceFromId_WhenEmptyLazyString_ShouldNotThrow()
{
using var ctx = DocumentsOperationContext.ShortTermSingleUse(null);
const string str = "";
var lazyString = ctx.GetLazyString(str);
using (DocumentIdWorker.GetSliceFromId(ctx, lazyString, out var lowerId))
{
Assert.Equal(str.ToLower(), lowerId.ToString());
}
}
public void WillVerifyEtags_OnDeleteNotThere()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
var changeVector = ctx.GetLazyString($"A:3-{_documentDatabase.DocumentsStorage.Environment.Base64Id}");
Assert.Throws <ConcurrencyException>(() => _documentDatabase.DocumentsStorage.Delete(ctx, "users/1", changeVector));
ctx.Transaction.Commit();
}
}
public void ErrorShouldIncludeTheActualItemAndReduceKey()
{
var numberOfDocs = 100;
using (var database = CreateDocumentDatabase())
{
using (var index = MapReduceIndex.CreateNew <MapReduceIndex>(new IndexDefinition()
{
Name = "Users_DivideByZero",
Maps = { @"from order in docs.Orders
from line in order.Lines
select new { Product = line.Product, FakeValue = 0 }" },
Reduce = @"from result in mapResults
group result by result.Product into g
select new
{
Product = g.Key,
FakeValue = (long) (128 / g.Sum(x=> x.Total) - g.Sum(x=> x.Count))
}",
}, database))
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
for (int i = 0; i < numberOfDocs; i++)
{
var order = CreateOrder();
PutOrder(database, order, context, i);
}
var stats = new IndexingRunStats();
var scope = new IndexingStatsScope(stats);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
try
{
index.DoIndexingWork(scope, cts.Token);
}
catch (ExcessiveNumberOfReduceErrorsException)
{
// expected
}
List <IndexingError> indexingErrors = stats.Errors;
Assert.Equal(1, indexingErrors.Count);
Assert.Contains(@"current item to reduce: {""Product"":""Milk"",""FakeValue"":0}", indexingErrors.First().Error);
Assert.Equal(@"Reduce key: { 'Product' : Milk }", indexingErrors.First().Document);
}
}
}
}
public async Task PatchByIndex_WhenFinish_ShouldFreeInternalUsageMemory()
{
using (var store = GetDocumentStore())
{
var database = await GetDatabase(store.Database);
var index = new IndexDefinition
{
Name = "Users_ByName",
Maps = { "from user in docs.Users select new { user.Name }" },
Type = IndexType.Map
};
await store
.Maintenance
.SendAsync(new PutIndexesOperation(new[] { index }));
using (var session = store.OpenAsyncSession())
{
for (var i = 0; i < 100; i++)
{
await session.StoreAsync(new User { Name = "John" });
}
await session.SaveChangesAsync();
}
WaitForIndexing(store);
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
var query = new IndexQueryServerSide($"FROM index '{index.Name}'");
var patch = new PatchRequest("var u = this; u.is = true;", PatchRequestType.Patch, query.Metadata.DeclaredFunctions);
var before = context.AllocatedMemory;
await database.QueryRunner.ExecutePatchQuery(
query,
new QueryOperationOptions { RetrieveDetails = true },
patch,
query.QueryParameters,
context,
p => { },
new OperationCancelToken(CancelAfter, CancellationToken.None));
var after = context.AllocatedMemory;
//In a case of fragmentation, we don't immediately freeing memory so the memory can be a little bit higher
const long threshold = 256;
Assert.True(Math.Abs(before - after) < threshold);
}
}
}
public void CanCreateAndGetTombstone()
{
using (var database = CreateDocumentDatabase())
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
{
DocumentsStorage.PutOperationResults result;
using (var tx = context.OpenWriteTransaction())
{
using (var doc = CreateDocument(context, "key/1", new DynamicJsonValue
{
["Name"] = "John",
[Constants.Documents.Metadata.Key] = new DynamicJsonValue
{
[Constants.Documents.Metadata.Collection] = "Users"
}
}))
{
result = database.DocumentsStorage.Put(context, "key/1", null, doc);
}
tx.Commit();
}
using (var tx = context.OpenWriteTransaction())
{
Assert.NotNull(database.DocumentsStorage.Delete(context, "key/1", null));
tx.Commit();
}
using (context.OpenReadTransaction())
{
var tombstones = database
.DocumentsStorage
.GetTombstonesFrom(context, "Users", 0, 0, int.MaxValue)
.ToList();
Assert.Equal(1, tombstones.Count);
var tombstone = tombstones[0];
Assert.True(tombstone.StorageId > 0);
Assert.Equal(result.Etag, tombstone.DeletedEtag);
Assert.Equal(result.Etag + 1, tombstone.Etag);
Assert.Equal(result.Id, tombstone.LowerId);
}
}
}
}
public async Task EtagsArePersistedWithDeletes()
{
Initialize();
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, "users/1", null, doc);
Assert.Equal(1, putResult.Etag);
_documentDatabase.DocumentsStorage.Delete(ctx, "users/1", null);
}
ctx.Transaction.Commit();
}
await Restart();
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/2", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, "users/2", null, doc);
//this should be 3 because in the use-case of this test,
//the tombstone that was created when users/1 was deleted, will have etag == 2
//thus, next document that is created will have etag == 3
Assert.Equal(3, putResult.Etag);
}
ctx.Transaction.Commit();
}
}
public void PutDocumentWithoutId()
{
Initialize();
var id = "users/";
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
for (int i = 1; i < 5; i++)
{
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["ThisDocId"] = $"{i}"
}, id + i, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, id + i, null, doc);
Assert.Equal(i, putResult.Etag);
}
}
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
_documentDatabase.DocumentsStorage.Delete(ctx, "users/2", null);
ctx.Transaction.Commit();
}
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["ThisDocId"] = "2"
}, id, BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, id + 5, null, doc);
Assert.True(putResult.Etag >= 5);
Assert.Equal("users/5", putResult.Id);
}
ctx.Transaction.Commit();
}
}
public async Task MultipleReduceKeys(int numberOfUsers, string[] locations)
{
using (var db = CreateDocumentDatabase())
using (var index = AutoMapReduceIndex.CreateNew(GetUsersCountByLocationIndexDefinition(), db))
{
CreateUsers(db, numberOfUsers, locations);
var batchStats = new IndexingRunStats();
var scope = new IndexingStatsScope(batchStats);
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
while (index.DoIndexingWork(scope, cts.Token))
{
;
}
Assert.Equal(numberOfUsers, batchStats.MapAttempts);
Assert.Equal(numberOfUsers, batchStats.MapSuccesses);
Assert.Equal(0, batchStats.MapErrors);
Assert.True(batchStats.ReduceAttempts >= numberOfUsers, $"{batchStats.ReduceAttempts} >= {numberOfUsers}");
Assert.True(batchStats.ReduceSuccesses >= numberOfUsers, $"{batchStats.ReduceSuccesses} >= {numberOfUsers}");
Assert.Equal(batchStats.ReduceAttempts, batchStats.ReduceSuccesses);
Assert.Equal(0, batchStats.ReduceErrors);
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
var queryResult = await index.Query(new IndexQueryServerSide($"FROM INDEX '{index.Name}'")
{
WaitForNonStaleResultsTimeout = TimeSpan.FromMinutes(1)
}, context, OperationCancelToken.None);
Assert.False(queryResult.IsStale);
var results = queryResult.Results;
Assert.Equal(locations.Length, results.Count);
for (int i = 0; i < locations.Length; i++)
{
Assert.Equal(locations[i], results[i].Data["Location"].ToString());
long expected = numberOfUsers / locations.Length + numberOfUsers % (locations.Length - i);
Assert.Equal(expected, results[i].Data["Count"]);
}
}
}
}
public async Task EtagsArePersisted()
{
Initialize();
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, "users/1", null, doc);
Assert.Equal(1, putResult.Etag);
}
ctx.Transaction.Commit();
}
await Restart();
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/2", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var putResult = _documentDatabase.DocumentsStorage.Put(ctx, "users/2", null, doc);
Assert.Equal(2, putResult.Etag);
}
ctx.Transaction.Commit();
}
}
private static void CreateOrders(DocumentDatabase db, int numberOfOrders, string[] countries = null, string[] employees = null, string[] companies = null)
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
using (var tx = context.OpenWriteTransaction())
{
for (int i = 0; i < numberOfOrders; i++)
{
using (var doc = context.ReadObject(new DynamicJsonValue
{
["Employee"] = employees?[i % employees.Length],
["Company"] = companies?[i % companies.Length],
["ShipTo"] = new DynamicJsonValue
{
["Country"] = countries?[i % countries.Length],
},
["Lines"] = new DynamicJsonArray
{
new DynamicJsonValue
{
["Price"] = 10.5,
["Quantity"] = 1
},
new DynamicJsonValue
{
["Price"] = 10.7,
["Quantity"] = 2
}
},
[Constants.Documents.Metadata.Key] = new DynamicJsonValue
{
[Constants.Documents.Metadata.Collection] = "Orders"
}
}, $"orders/{i}"))
{
db.DocumentsStorage.Put(context, $"orders/{i}", null, doc);
}
}
tx.Commit();
}
}
}
public async Task CanUseSimpleReduction()
{
using (var db = CreateDocumentDatabase())
using (var mri = AutoMapReduceIndex.CreateNew(1, GetUsersCountByLocationIndexDefinition(), db))
{
CreateUsers(db, 2, "Poland");
mri.DoIndexingWork(new IndexingStatsScope(new IndexingRunStats()), CancellationToken.None);
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
var queryResult = await mri.Query(new IndexQueryServerSide(), context, OperationCancelToken.None);
Assert.Equal(1, queryResult.Results.Count);
var result = queryResult.Results[0].Data;
string location;
Assert.True(result.TryGet("Location", out location));
Assert.Equal("Poland", location);
var count = result["Count"];
Assert.Equal(2L, count);
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
var queryResult = await mri.Query(new IndexQueryServerSide()
{
Query = "Count_Range:[Lx2 TO Lx10]"
}, context, OperationCancelToken.None);
Assert.Equal(1, queryResult.Results.Count);
queryResult = await mri.Query(new IndexQueryServerSide()
{
Query = "Count_Range:[Lx10 TO NULL]"
}, context, OperationCancelToken.None);
Assert.Equal(0, queryResult.Results.Count);
}
}
}
public void WillVerifyEtags_New()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["Raven-Entity-Name"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
Assert.Throws <ConcurrencyException>(() => _documentDatabase.DocumentsStorage.Put(ctx, "users/1", 1, doc));
}
ctx.Transaction.Commit();
}
}
public void WillVerifyEtags_VerifyNew()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var changeVector = ctx.GetLazyString("");
_documentDatabase.DocumentsStorage.Put(ctx, "users/1", changeVector, doc);
}
ctx.Transaction.Commit();
}
}
public void WillVerifyEtags_New()
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(_documentDatabase))
{
ctx.OpenWriteTransaction();
using (var doc = ctx.ReadObject(new DynamicJsonValue
{
["Name"] = "Oren",
["@metadata"] = new DynamicJsonValue
{
["@collection"] = "Users"
}
}, "users/1", BlittableJsonDocumentBuilder.UsageMode.ToDisk))
{
var changeVector = ctx.GetLazyString($"A:1-{_documentDatabase.DocumentsStorage.Environment.Base64Id}");
Assert.Throws <ConcurrencyException>(() => _documentDatabase.DocumentsStorage.Put(ctx, "users/1", changeVector, doc));
}
ctx.Transaction.Commit();
}
}
public MergedBatchPutCommand(DocumentDatabase database, BuildVersionType buildType,
Logger log, ConcurrentDictionary <string, CollectionName> missingDocumentsForRevisions = null)
{
_database = database;
_buildType = buildType;
_log = log;
_resetContext = _database.DocumentsStorage.ContextPool.AllocateOperationContext(out _context);
_missingDocumentsForRevisions = missingDocumentsForRevisions;
Is32Bit = _database.Configuration.Storage.ForceUsing32BitsPager || PlatformDetails.Is32Bits;
if (Is32Bit)
{
using (var ctx = DocumentsOperationContext.ShortTermSingleUse(database))
using (ctx.OpenReadTransaction())
{
_collectionNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var collection in _database.DocumentsStorage.GetCollections(ctx))
{
_collectionNames.Add(collection.Name);
}
}
}
}
private static void PutUser(DocumentDatabase db)
{
using (var context = DocumentsOperationContext.ShortTermSingleUse(db))
{
using (var tx = context.OpenWriteTransaction())
{
using (var doc = CreateDocument(context, "users/1", new DynamicJsonValue
{
["Name"] = "John",
[Constants.Documents.Metadata.Key] = new DynamicJsonValue
{
[Constants.Documents.Metadata.Collection] = "Users"
}
}))
{
db.DocumentsStorage.Put(context, "users/1", null, doc);
}
tx.Commit();
}
}
}