public async Task CanDeleteAndUpdateDocumentByIndex()
{
var usersByNameIndex = new Users_ByName();
using (var store = GetDocumentStore())
{
store.DatabaseCommands.PutIndex("MyIndex", new IndexDefinition
{
Map = "from doc in docs select new { Name }"
});
store.DatabaseCommands.Put("items/1", null, RavenJObject.FromObject(new
{
Name = "testname"
}), new RavenJObject());
WaitForIndexing(store);
store.DatabaseCommands.UpdateByIndex("MyIndex", new IndexQuery { Query = "" }, new[]
{
new PatchRequest
{
Type = PatchCommandType.Set,
Name = "NewName",
Value = "NewValue"
}
},
false).WaitForCompletion();
var document = await store.AsyncDatabaseCommands.GetAsync("items/1");
Assert.Equal("NewValue", document.DataAsJson.Value<string>("NewName"));
store.DatabaseCommands.DeleteByIndex("MyIndex", new IndexQuery { Query = "" }, false).WaitForCompletion();
var documents = store.DatabaseCommands.GetDocuments(0, 25);
Assert.Equal(0, documents.Length);
}
}
public async Task CanDeleteAndUpdateDocumentByIndex()
{
var usersByNameIndex = new Users_ByName();
using (var store = GetDocumentStore())
{
store.DatabaseCommands.PutIndex("MyIndex", new IndexDefinition
{
Map = "from doc in docs select new { Name }"
});
store.DatabaseCommands.Put("items/1", null, RavenJObject.FromObject(new
{
Name = "testname"
}), new RavenJObject());
WaitForIndexing(store);
store.DatabaseCommands.UpdateByIndex("MyIndex", new IndexQuery { Query = "" }, new[]
{
new PatchRequest
{
Type = PatchCommandType.Set,
Name = "NewName",
Value = "NewValue"
}
},
null).WaitForCompletion();
var document = await store.AsyncDatabaseCommands.GetAsync("items/1");
Assert.Equal("NewValue", document.DataAsJson.Value<string>("NewName"));
store.DatabaseCommands.DeleteByIndex("MyIndex", new IndexQuery { Query = "" }, null).WaitForCompletion();
var documents = store.DatabaseCommands.GetDocuments(0, 25);
Assert.Equal(0, documents.Length);
}
}
public async Task CanResetIndex()
{
var index = new Users_ByName();
using (var store = GetDocumentStore())
{
index.Execute(store);
for (var i = 0; i < 20; i++)
{
await store.AsyncDatabaseCommands.PutAsync("users/" + i, null, RavenJObject.FromObject(new User {
}), new RavenJObject());
}
WaitForIndexing(store);
var stats = await store.AsyncDatabaseCommands.GetStatisticsAsync();
Assert.Equal(0, stats.StaleIndexes.Length);
await store.AsyncDatabaseCommands.Admin.StopIndexingAsync();
await store.AsyncDatabaseCommands.ResetIndexAsync(index.IndexName);
stats = await store.AsyncDatabaseCommands.GetStatisticsAsync();
Assert.Equal(1, stats.StaleIndexes.Length);
Assert.Equal(index.IndexName, stats.StaleIndexes[0]);
}
}
public void CanGetSuggestions()
{
using (var store = GetDocumentStore())
{
var index = new Users_ByName();
index.Execute(store);
using (var s = store.OpenSession())
{
s.Store(new User {
Name = "John Smith"
}, "users/1");
s.Store(new User {
Name = "Jack Johnson"
}, "users/2");
s.Store(new User {
Name = "Robery Jones"
}, "users/3");
s.Store(new User {
Name = "David Jones"
}, "users/4");
s.SaveChanges();
}
WaitForIndexing(store);
using (var session = store.OpenSession())
{
var suggestions = session.Query <User, Users_ByName> ()
.Suggest(new SuggestionQuery
{
Field = "Name",
Term = "<<johne davi>>",
Accuracy = 0.4f,
MaxSuggestions = 5,
Distance = StringDistanceTypes.JaroWinkler,
Popularity = true,
});
Assert.Equal(5, suggestions.Suggestions.Length);
Assert.Equal("john", suggestions.Suggestions[0]);
Assert.Equal("jones", suggestions.Suggestions[1]);
Assert.Equal("johnson", suggestions.Suggestions[2]);
Assert.Equal("david", suggestions.Suggestions[3]);
Assert.Equal("jack", suggestions.Suggestions[4]);
}
}
}
public void CanUseMoreLikeThisWithIncludes()
{
using (var store = GetDocumentStore())
{
var index = new Users_ByName();
index.Execute(store);
using (var session = store.OpenSession())
{
session.Store(new User {
Id = "users/1", AddressId = "addresses/1", Name = "John"
});
session.Store(new User {
Id = "users/2", AddressId = "addresses/2", Name = "John Doe"
});
session.Store(new Address {
Id = "addresses/1", City = "New York", Country = "USA"
});
session.Store(new Address {
Id = "addresses/2", City = "New York2", Country = "USA2"
});
session.SaveChanges();
WaitForIndexing(store);
var list = session.Advanced.MoreLikeThis <User>(new MoreLikeThisQuery()
{
Query = $"FROM INDEX '{new Users_ByName().IndexName}'",
DocumentId = "users/1",
Includes = new[] { "AddressId" },
MinimumDocumentFrequency = 1,
MinimumTermFrequency = 0
});
Assert.Equal(1, list.Count);
Assert.Equal("John Doe", list[0].Name);
var address = session.Load <Address>(list[0].AddressId);
Assert.Equal("USA2", address.Country);
}
}
}
public void CanStreamQueryResult()
{
using (var store = GetDocumentStore())
{
var index = new Users_ByName();
index.Execute(store);
for (int i = 0; i < 30; i++)
{
store.DatabaseCommands.Put("users/" + i, null, RavenJObject.FromObject(new User { Name = "Name"+i }), new RavenJObject { { "Raven-Entity-Name", "Users" } });
}
WaitForIndexing(store);
int count = 0;
QueryHeaderInformation queryHeaders = null;
var reader = store.DatabaseCommands.StreamQuery(index.IndexName, new IndexQuery { Query = "" }, out queryHeaders);
while (reader.MoveNext())
{
Assert.Equal("Name" + count, reader.Current.Value<string>("Name"));
count++;
}
Assert.Equal(30, count);
}
}
public void CanUseMoreLikeThisWithIncludes()
{
using (var store = GetDocumentStore())
{
var index = new Users_ByName();
index.Execute(store);
using (var session = store.OpenSession())
{
session.Store(new User { Id = "users/1", AddressId = "addresses/1", Name = "John" });
session.Store(new User { Id = "users/2", AddressId = "addresses/2", Name = "John Doe" });
session.Store(new Address { Id = "addresses/1", City = "New York", Country = "USA" });
session.Store(new Address { Id = "addresses/2", City = "New York2", Country = "USA2" });
session.SaveChanges();
WaitForIndexing(store);
var list = session.Advanced.MoreLikeThis<User, Users_ByName>(new MoreLikeThisQuery
{
DocumentId = "users/1",
Includes = new [] {"AddressId"},
MinimumDocumentFrequency = 1,
MinimumTermFrequency = 0
});
Assert.Equal(1, list.Length);
Assert.Equal("John Doe", list[0].Name);
var address = session.Load<Address>(list[0].AddressId);
Assert.Equal("USA2", address.Country);
}
}
}
public void CanSubscribeToIndexChanges()
{
using (var store = GetDocumentStore())
{
store.Changes().Task.Result
.ForAllIndexes().Task.Result
.Subscribe(change =>
{
if (change.Type == IndexChangeTypes.IndexAdded)
{
output = "passed_forallindexesadded";
}
});
new Companies_CompanyByType().Execute(store);
WaitForIndexing(store);
WaitUntilOutput("passed_forallindexesadded");
var usersByName = new Users_ByName();
usersByName.Execute(store);
WaitForIndexing(store);
store.Changes().Task.Result
.ForIndex(usersByName.IndexName).Task.Result
.Subscribe(change =>
{
if (change.Type == IndexChangeTypes.MapCompleted)
{
output = "passed_forindexmapcompleted";
}
});
var companiesSompanyByType = new Companies_CompanyByType();
companiesSompanyByType.Execute(store);
WaitForIndexing(store);
store.Changes().Task.Result
.ForIndex(companiesSompanyByType.IndexName).Task.Result
.Subscribe(change =>
{
if (change.Type == IndexChangeTypes.RemoveFromIndex)
{
output2 = "passed_forindexremovecompleted";
}
if (change.Type == IndexChangeTypes.ReduceCompleted)
{
output = "passed_forindexreducecompleted";
}
});
using (var session = store.OpenSession())
{
session.Store(new User { Name = "user", LastName = "user" });
session.SaveChanges();
WaitForIndexing(store);
WaitUntilOutput("passed_forindexmapcompleted");
session.Store(new Company { Id = "companies/1", Name = "company", Type = Company.CompanyType.Public });
session.SaveChanges();
WaitForIndexing(store);
WaitUntilOutput("passed_forindexreducecompleted");
session.Delete("companies/1");
session.SaveChanges();
WaitForIndexing(store);
WaitUntilOutput2("passed_forindexremovecompleted");
}
store.Changes().Task.Result
.ForAllIndexes().Task.Result
.Subscribe(change =>
{
if (change.Type == IndexChangeTypes.IndexRemoved)
{
output = "passed_forallindexesremoved";
}
});
store.DatabaseCommands.DeleteIndex("Companies/CompanyByType");
WaitForIndexing(store);
Assert.Equal("passed_forallindexesremoved", output);
}
}
public void CanGetSuggestions()
{
using (var store = GetDocumentStore())
{
var index = new Users_ByName();
index.Execute(store);
store.DatabaseCommands.Put("users/1", null, RavenJObject.FromObject(new User { Name = "John Smith" }), new RavenJObject { { "Raven-Entity-Name", "Users" } });
store.DatabaseCommands.Put("users/2", null, RavenJObject.FromObject(new User { Name = "Jack Johnson" }), new RavenJObject { { "Raven-Entity-Name", "Users" } });
store.DatabaseCommands.Put("users/3", null, RavenJObject.FromObject(new User { Name = "Robery Jones" }), new RavenJObject { { "Raven-Entity-Name", "Users" } });
store.DatabaseCommands.Put("users/4", null, RavenJObject.FromObject(new User { Name = "David Jones" }), new RavenJObject { { "Raven-Entity-Name", "Users" } });
WaitForIndexing(store);
var suggestions = store.DatabaseCommands.Suggest(index.IndexName, new SuggestionQuery()
{
Field = "Name",
Term = "<<johne davi>>",
Accuracy = 0.4f,
MaxSuggestions = 5,
Distance = StringDistanceTypes.JaroWinkler,
Popularity = true,
});
Assert.Equal("john", suggestions.Suggestions[0]);
Assert.Equal("jones", suggestions.Suggestions[1]);
Assert.Equal("johnson", suggestions.Suggestions[2]);
Assert.Equal("david", suggestions.Suggestions[3]);
Assert.Equal("jack", suggestions.Suggestions[4]);
}
}
public async Task CanResetIndex()
{
var index = new Users_ByName();
using (var store = GetDocumentStore())
{
index.Execute(store);
for (var i = 0; i < 20; i++)
{
await store.AsyncDatabaseCommands.PutAsync("users/" + i, null, RavenJObject.FromObject(new User { }), new RavenJObject());
}
WaitForIndexing(store);
var stats = await store.AsyncDatabaseCommands.GetStatisticsAsync();
Assert.Equal(0, stats.StaleIndexes.Length);
await store.AsyncDatabaseCommands.Admin.StopIndexingAsync();
await store.AsyncDatabaseCommands.ResetIndexAsync(index.IndexName);
stats = await store.AsyncDatabaseCommands.GetStatisticsAsync();
Assert.Equal(1, stats.StaleIndexes.Length);
Assert.Equal(index.IndexName, stats.StaleIndexes[0]);
}
}
public async Task CanGetIndexNames()
{
var index1 = new Users_ByName();
var index2 = new Posts_Recurse();
using (var store = GetDocumentStore())
{
index1.Execute(store);
index2.Execute(store);
var indexes = await store.AsyncDatabaseCommands.GetIndexNamesAsync(0, 10);
Assert.Equal(2, indexes.Length);
Assert.Equal(index1.IndexName, indexes[1]);
Assert.Equal(index2.IndexName, indexes[0]);
}
}