public void Can_use_transactions_to_isolate_saves(string storage)
{
using (var documentStore = NewDocumentStore(requestedStorage: storage))
{
EnsureDtcIsSupported(documentStore);
var company = new Company {
Name = "Company Name"
};
var session = documentStore.OpenSession();
using (RavenTransactionAccessor.StartTransaction())
{
session.Store(company);
session.SaveChanges();
using (RavenTransactionAccessor.StartTransaction())
{
using (var session2 = documentStore.OpenSession())
Assert.Null(session2.Load <Company>(company.Id));
}
Assert.NotNull(session.Load <Company>(company.Id));
documentStore.DatabaseCommands.PrepareTransaction(RavenTransactionAccessor.GetTransactionInformation().Id);
documentStore.DatabaseCommands.Commit(RavenTransactionAccessor.GetTransactionInformation().Id);
}
Assert.NotNull(session.Load <Company>(company.Id));
}
}
public void Will_process_all_different_documents_enlisted_in_a_transaction(string storage)
{
using (var documentStore = NewDocumentStore(requestedStorage: storage))
{
EnsureDtcIsSupported(documentStore);
using (RavenTransactionAccessor.StartTransaction())
{
using (var session = documentStore.OpenSession())
{
// Remark: Don't change the order of the stored classes!
// This test will only fail if the classes are not
// stored in their alphabetical order!
session.Store(new Contact {
FirstName = "Contact"
});
session.Store(new Company {
Name = "Company"
});
session.SaveChanges();
}
documentStore.DatabaseCommands.PrepareTransaction(RavenTransactionAccessor.GetTransactionInformation().Id);
documentStore.DatabaseCommands.Commit(RavenTransactionAccessor.GetTransactionInformation().Id);
}
Thread.Sleep(100);
using (var session = documentStore.OpenSession())
{
Assert.NotNull(session.Load <Contact>("contacts/1"));
Assert.NotNull(session.Load <Company>("companies/1"));
session.SaveChanges();
}
}
}
/// <summary>
/// Perform a set based deletes using the specified index.
/// </summary>
/// <param name="indexName">Name of the index.</param>
/// <param name="queryToDelete">The query to delete.</param>
/// <param name="allowStale">if set to <c>true</c> [allow stale].</param>
public void DeleteByIndex(string indexName, IndexQuery queryToDelete, bool allowStale)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
var databaseBulkOperations = new DatabaseBulkOperations(database, RavenTransactionAccessor.GetTransactionInformation());
databaseBulkOperations.DeleteByIndex(indexName, queryToDelete, allowStale);
}
/// <summary>
/// Perform a set based update using the specified index
/// </summary>
/// <param name="indexName">Name of the index.</param>
/// <param name="queryToUpdate">The query to update.</param>
/// <param name="patch">The patch request to use (using JavaScript)</param>
/// <param name="allowStale">if set to <c>true</c> [allow stale].</param>
public void UpdateByIndex(string indexName, IndexQuery queryToUpdate, ScriptedPatchRequest patch, bool allowStale)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
var databaseBulkOperations = new DatabaseBulkOperations(database, RavenTransactionAccessor.GetTransactionInformation());
databaseBulkOperations.UpdateByIndex(indexName, queryToUpdate, patch, allowStale);
}
/// <summary>
/// Rollbacks the transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
internal static void RollbackTransaction(Transaction transaction)
{
var stack = CurrentStack;
stack.TransactionState = StackInfo.TransactionStateEnum.Rollback;
stack.Session.Rollback(RavenTransactionAccessor.GetTransactionInformation().Id);
}
/// <summary>
/// Gets the document for the specified key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public JsonDocument Get(string key)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
var jsonDocument = database.Get(key, RavenTransactionAccessor.GetTransactionInformation());
return(EnsureLocalDate(jsonDocument));
}
/// <summary>
/// Executed the specified commands as a single batch
/// </summary>
/// <param name="commandDatas">The command data.</param>
public BatchResult[] Batch(IEnumerable <ICommandData> commandDatas)
{
foreach (var commandData in commandDatas)
{
commandData.TransactionInformation = RavenTransactionAccessor.GetTransactionInformation();
}
CurrentOperationContext.Headers.Value = OperationsHeaders;
return(database.Batch(commandDatas));
}
/// <summary>
/// Gets the results for the specified ids.
/// </summary>
/// <param name="ids">The ids.</param>
/// <param name="includes">The includes.</param>
/// <returns></returns>
public MultiLoadResult Get(string[] ids, string[] includes)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
return(new MultiLoadResult
{
Results = ids
.Select(id => database.Get(id, RavenTransactionAccessor.GetTransactionInformation()))
.Where(document => document != null)
.Select(x => EnsureLocalDate(x).ToJson())
.ToList()
});
}
/// <summary>
/// Registers the transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
internal static void RegisterTransaction(Transaction transaction)
{
var stack = CurrentStack;
// if no session yet, start new
if (stack.Session == null)
{
stack.Session = (DocumentSession)transaction.DocumentStoreInstance.OpenSession();
}
// and if no transaction yet, then start new one
if (stack.TopTransaction == null)
{
stack.TopTransaction = transaction;
stack.Transaction = RavenTransactionAccessor.StartTransaction();
stack.TransactionState = StackInfo.TransactionStateEnum.Active;
}
}
/// <summary>
/// Commits the transaction.
/// </summary>
/// <param name="transaction">The transaction.</param>
internal static void CommitTransaction(Transaction transaction)
{
var stack = CurrentStack;
if (stack.TopTransaction == transaction)
{
if (stack.TransactionState == StackInfo.TransactionStateEnum.Rollback)
{
throw new SessionException("Nested transaction called Rollback and thus we are not able to commit!");
}
stack.Session.SaveChanges();
stack.TransactionState = StackInfo.TransactionStateEnum.Commit;
stack.Session.Commit(RavenTransactionAccessor.GetTransactionInformation().Id);
}
else
{
stack.Session.SaveChanges();
}
}
public void Can_use_transactions_to_isolate_saves()
{
using (var documentStore = NewDocumentStore())
{
var company = new Company {
Name = "Company Name"
};
var session = documentStore.OpenSession();
using (RavenTransactionAccessor.StartTransaction())
{
session.Store(company);
session.SaveChanges();
using (RavenTransactionAccessor.StartTransaction())
{
using (var session2 = documentStore.OpenSession())
Assert.Null(session2.Load <Company>(company.Id));
}
Assert.NotNull(session.Load <Company>(company.Id));
documentStore.DatabaseCommands.Commit(RavenTransactionAccessor.GetTransactionInformation().Id);
}
Assert.NotNull(session.Load <Company>(company.Id));
}
}
/// <summary>
/// Deletes the document with the specified key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
public void Delete(string key, Guid?etag)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
database.Delete(key, etag, RavenTransactionAccessor.GetTransactionInformation());
}
/// <summary>
/// Puts the document with the specified key in the database
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
/// <param name="document">The document.</param>
/// <param name="metadata">The metadata.</param>
/// <returns></returns>
public PutResult Put(string key, Guid?etag, RavenJObject document, RavenJObject metadata)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
return(database.Put(key, etag, document, metadata, RavenTransactionAccessor.GetTransactionInformation()));
}
private RangeValue GetNextRange(IDatabaseCommands databaseCommands)
{
#if !NETFX_CORE
using (new TransactionScope(TransactionScopeOption.Suppress))
using (RavenTransactionAccessor.SupressExplicitRavenTransaction())
using (databaseCommands.ForceReadFromMaster())
{
#endif
ModifyCapacityIfRequired();
while (true)
{
try
{
var minNextMax = Range.Max;
JsonDocument document;
try
{
document = GetDocument(databaseCommands);
}
catch (ConflictException e)
{
// resolving the conflict by selecting the highest number
var highestMax = e.ConflictedVersionIds
.Select(conflictedVersionId => GetMaxFromDocument(databaseCommands.Get(conflictedVersionId), minNextMax))
.Max();
PutDocument(databaseCommands, new JsonDocument
{
Etag = e.Etag,
Metadata = new RavenJObject(),
DataAsJson = RavenJObject.FromObject(new { Max = highestMax }),
Key = HiLoDocumentKey
});
continue;
}
long min, max;
if (document == null)
{
min = minNextMax + 1;
max = minNextMax + capacity;
document = new JsonDocument
{
Etag = Etag.Empty,
// sending empty etag means - ensure the that the document does NOT exists
Metadata = new RavenJObject(),
DataAsJson = RavenJObject.FromObject(new { Max = max }),
Key = HiLoDocumentKey
};
}
else
{
var oldMax = GetMaxFromDocument(document, minNextMax);
min = oldMax + 1;
max = oldMax + capacity;
document.DataAsJson["Max"] = max;
}
PutDocument(databaseCommands, document);
return(new RangeValue(min, max));
}
catch (ConcurrencyException)
{
// expected, we need to retry
}
}
#if !NETFX_CORE
}
#endif
}
/// <summary>
/// Gets the document for the specified key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public JsonDocument Get(string key)
{
CurrentOperationContext.Headers.Value = OperationsHeaders;
return(database.Get(key, RavenTransactionAccessor.GetTransactionInformation()));
}
