/// <summary>
/// Executes the index creation against each of the shards.
/// </summary>
public override void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
var list = ShardStrategy.Shards.Values.Select(x => x.DatabaseCommands).ToList();
ShardStrategy.ShardAccessStrategy.Apply <object>(list, (commands, i) =>
{
indexCreationTask.Execute(commands, Conventions);
return(null);
});
}
public void PutIndex(AbstractIndexCreationTask index)
{
var response = httpClient
.PutAsync(databaseUrl + "/indexes/" + Uri.EscapeUriString(index.IndexName), new JsonContent(RavenJObject.FromObject(index.CreateIndexDefinition())))
.ResultUnwrap();
if (response.IsSuccessStatusCode == false)
{
throw new InvalidOperationException(string.Format("PUT failed on '{0}'. Code: {1}.", index.IndexName, response.StatusCode));
}
}
public override void SideBySideExecuteIndex(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
var list = ShardStrategy.Shards.Values.Select(x => x.DatabaseCommands).ToList();
ShardStrategy.ShardAccessStrategy.Apply(list,
new ShardRequestData()
, (commands, i) =>
{
indexCreationTask.SideBySideExecute(commands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc);
return((object)null);
});
}
/// <summary>
/// Safely add the index to the RavenDB database, protect against possible failures caused by documented
/// and undocumented possibilities of failure.
/// Will throw iff index registration failed and index doesn't exist or it exists but with a non-current definition.
/// </summary>
/// <param name="store"></param>
/// <param name="index"></param>
internal static void SafelyCreateIndex(IDocumentStore store, AbstractIndexCreationTask index)
{
try
{
index.Execute(store);
}
catch (Exception) // Apparently ArgumentException can be thrown as well as a WebException; not taking any chances
{
var existingIndex = store.DatabaseCommands.GetIndex(index.IndexName);
if (existingIndex == null || !index.CreateIndexDefinition().Equals(existingIndex))
{
throw;
}
}
}
private void CanUseOverLoad(AbstractIndexCreationTask index)
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Order
{
Company = "Hibernating Rhinos"
});
session.SaveChanges();
}
index.Execute(store);
Indexes.WaitForIndexing(store);
Assert.Null(Indexes.WaitForIndexingErrors(store, errorsShouldExists: false));
}
}
private void CanUseOverLoad(AbstractIndexCreationTask index)
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Order
{
Company = "Hibernating Rhinos"
});
session.SaveChanges();
}
index.Execute(store);
WaitForIndexing(store);
var errors = store.Maintenance.Send(new GetIndexErrorsOperation());
Assert.Equal(0, errors[0].Errors.Length);
}
}
/// <summary>
/// Executes the index creation against each of the shards Async.
/// </summary>
public override Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
var list = ShardStrategy.Shards.Values.Select(x => x.AsyncDatabaseCommands).ToList();
return(ShardStrategy.ShardAccessStrategy.ApplyAsync(list, new ShardRequestData(), (commands, i) =>
{
var tcs = new TaskCompletionSource <bool>();
try
{
indexCreationTask.ExecuteAsync(commands, Conventions)
.ContinueWith(t => tcs.SetResult(true));
}
catch (Exception e)
{
tcs.SetException(e);
}
return tcs.Task;
}));
}
public override Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
var list = ShardStrategy.Shards.Values.Select(x => x.AsyncDatabaseCommands).ToList();
return(ShardStrategy.ShardAccessStrategy.ApplyAsync(list, new ShardRequestData(), (commands, i) =>
{
var tcs = new TaskCompletionSource <bool>();
try
{
indexCreationTask.SideBySideExecuteAsync(commands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc)
.ContinueWith(t => tcs.SetResult(true));
}
catch (Exception e)
{
tcs.SetException(e);
}
return tcs.Task;
}));
}
/// <summary>
/// Executes index creation.
/// </summary>
public virtual Task ExecuteIndexAsync(AbstractIndexCreationTask task, CancellationToken token = default(CancellationToken))
{
return(task.ExecuteAsync(this, Conventions, token));
}
/// <summary>
/// Executes index creation.
/// </summary>
public virtual void ExecuteIndex(AbstractIndexCreationTask task)
{
AsyncHelpers.RunSync(() => ExecuteIndexAsync(task));
}
public Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
return(Inner.ExecuteIndexAsync(indexCreationTask));
}
public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
this.ThrowIfNotInitialized();
this.InnerStore.ExecuteIndex(indexCreationTask);
}
/// <summary>
/// Executes the index creation using side-by-side mode.
/// </summary>
/// <param name="indexCreationTask"></param>
/// <param name="minimumEtagBeforeReplace"></param>
/// <param name="replaceTimeUtc"></param>
public void SideBySideExecuteIndex(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
server.DocumentStore.SideBySideExecuteIndex(indexCreationTask, minimumEtagBeforeReplace, replaceTimeUtc);
}
/// <summary>
/// Executes the index creation.
/// </summary>
public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
server.DocumentStore.ExecuteIndex(indexCreationTask);
}
public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
_docStore.ExecuteIndex(indexCreationTask);
}
/// <summary>
/// Executes index creation in side-by-side mode.
/// </summary>
public virtual Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
return(indexCreationTask.SideBySideExecuteAsync(AsyncDatabaseCommands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc));
}
/// <summary>
/// Executes index creation in side-by-side mode.
/// </summary>
public virtual void SideBySideExecuteIndex(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
indexCreationTask.SideBySideExecute(DatabaseCommands, Conventions, minimumEtagBeforeReplace, replaceTimeUtc);
}
public void RegisterIndex(AbstractIndexCreationTask type)
{
IndexCreation.CreateIndexes(new List <AbstractIndexCreationTask> {
type
}, _store);
}
/// <inheritdoc />
public virtual Task ExecuteIndexAsync(AbstractIndexCreationTask task, string database = null, CancellationToken token = default)
{
AssertInitialized();
return(task.ExecuteAsync(this, Conventions, database, token));
}
/// <inheritdoc />
public virtual void ExecuteIndex(AbstractIndexCreationTask task, string database = null)
{
AsyncHelpers.RunSync(() => ExecuteIndexAsync(task, database));
}
/// <summary>
/// Executes the index creation.
/// </summary>
public virtual void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
indexCreationTask.Execute(DatabaseCommands, Conventions);
}
/// <summary>
/// Executes index creation.
/// </summary>
public virtual Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
return(indexCreationTask.ExecuteAsync(Conventions));
}
public virtual Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
return(indexCreationTask.ExecuteAsync(AsyncDatabaseCommands, Conventions));
}
internal Task ExecuteIndex(IDocumentStore store, AbstractIndexCreationTask index) => index.ExecuteAsync(store);
public Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
return(_docStore.ExecuteIndexAsync(indexCreationTask));
}
/// <summary>
/// Safely add the index to the RavenDB database, protect against possible failures caused by documented
/// and undocumented possibilities of failure.
/// Will throw iff index registration failed and index doesn't exist or it exists but with a non-current definition.
/// </summary>
internal void CreateIndexOnInitialization(AbstractIndexCreationTask index)
{
indexesToCreate.Add(index);
}
/// <summary>
/// Executes the index creation.
/// </summary>
/// <param name="indexCreationTask"></param>
public Task ExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask)
{
return(server.DocumentStore.ExecuteIndexAsync(indexCreationTask));
}
public void ExecuteIndex(AbstractIndexCreationTask indexCreationTask)
{
Inner.ExecuteIndex(indexCreationTask);
}
/// <summary>
/// Executes the index creation using side-by-side mode.
/// </summary>
/// <param name="indexCreationTask"></param>
/// <param name="minimumEtagBeforeReplace"></param>
/// <param name="replaceTimeUtc"></param>
/// <returns></returns>
public Task SideBySideExecuteIndexAsync(AbstractIndexCreationTask indexCreationTask, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
return(server.DocumentStore.SideBySideExecuteIndexAsync(indexCreationTask, minimumEtagBeforeReplace, replaceTimeUtc));
}
private async Task Can_Use_No_Tracking_For_Referenced_Items_Internal(AbstractIndexCreationTask productsBySupplierNoTracking, AbstractIndexCreationTask productsBySupplier)
{
using (var store = GetDocumentStore())
{
await productsBySupplierNoTracking.ExecuteAsync(store);
await productsBySupplier.ExecuteAsync(store);
var database = await Databases.GetDocumentDatabaseInstanceFor(store);
var i = database.IndexStore.GetIndex(productsBySupplierNoTracking.IndexName);
Assert.Empty(i.GetReferencedCollections());
i = database.IndexStore.GetIndex(productsBySupplier.IndexName);
Assert.NotEmpty(i.GetReferencedCollections());
using (var session = store.OpenAsyncSession())
{
var supplier = new Supplier {
Name = "Bob"
};
await session.StoreAsync(supplier, "suppliers/1");
var product = new Product {
Name = "Cheese", Supplier = supplier.Id
};
await session.StoreAsync(product, "products/1");
await session.SaveChangesAsync();
}
Indexes.WaitForIndexing(store);
var terms = await store.Maintenance.SendAsync(new GetTermsOperation(productsBySupplierNoTracking.IndexName, "Name", fromValue : null));
Assert.Equal(1, terms.Length);
Assert.Equal("bob", terms[0]);
terms = await store.Maintenance.SendAsync(new GetTermsOperation(productsBySupplier.IndexName, "Name", fromValue : null));
Assert.Equal(1, terms.Length);
Assert.Equal("bob", terms[0]);
using (var session = store.OpenAsyncSession())
{
var supplier = await session.LoadAsync <Supplier>("suppliers/1");
supplier.Name = "John";
await session.SaveChangesAsync();
}
Indexes.WaitForIndexing(store);
terms = await store.Maintenance.SendAsync(new GetTermsOperation(productsBySupplierNoTracking.IndexName, "Name", fromValue : null));
Assert.Equal(1, terms.Length);
Assert.Equal("bob", terms[0]);
terms = await store.Maintenance.SendAsync(new GetTermsOperation(productsBySupplier.IndexName, "Name", fromValue : null));
Assert.Equal(1, terms.Length);
Assert.Equal("john", terms[0]);
}
}
