public void DeletingDocumentInTransactionInNotVisibleBeforeCommit()
{
db.Put("ayende", null, RavenJObject.Parse("{ayende:'oren'}"), new RavenJObject(), null);
var transactionInformation = new TransactionInformation {
Id = Guid.NewGuid(), Timeout = TimeSpan.FromMinutes(1)
};
db.Delete("ayende", null, transactionInformation);
Assert.NotNull(db.Get("ayende", null));
}
private void RecordSuccess(string url,
Guid?lastReplicatedEtag = null, DateTime?lastReplicatedLastModified = null,
DateTime?lastHeartbeatReceived = null, string lastError = null)
{
var stats = destinationStats.GetOrAdd(url, new DestinationStats {
Url = url
});
Interlocked.Exchange(ref stats.FailureCountInternal, 0);
stats.LastSuccessTimestamp = SystemTime.UtcNow;
if (lastReplicatedEtag.HasValue)
{
stats.LastEtagCheckedForReplication = lastReplicatedEtag;
stats.LastReplicatedEtag = lastReplicatedEtag;
}
if (lastReplicatedLastModified.HasValue)
{
stats.LastReplicatedLastModified = lastReplicatedLastModified;
}
if (lastHeartbeatReceived.HasValue)
{
stats.LastHeartbeatReceived = lastHeartbeatReceived;
}
if (!String.IsNullOrWhiteSpace(lastError))
{
stats.LastError = lastError;
}
docDb.Delete(Constants.RavenReplicationDestinationsBasePath + EscapeDestinationName(url), null,
null);
}
public void CanDelete()
{
var values = new[]
{
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{},{},{},{}]}",
"{blog_id: 6, comments: [{},{},{},{},{},{}]}",
"{blog_id: 7, comments: [{}]}",
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 3, comments: [{},{},{},{},{}]}",
"{blog_id: 2, comments: [{},{},{},{},{},{},{},{}]}",
"{blog_id: 4, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{},{}]}",
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{}]}",
};
for (int i = 0; i < values.Length; i++)
{
db.Put("docs/" + i, null, RavenJObject.Parse(values[i]), new RavenJObject(), null);
}
GetUnstableQueryResult("blog_id:3");
db.Delete("docs/0", null, null);
var q = GetUnstableQueryResult("blog_id:3");
Assert.Equal(@"{""blog_id"":""3"",""comments_length"":""11""}", q.Results[0].ToString(Formatting.None));
}
private void CompleteBackup()
{
try
{
logger.Info("Backup completed");
var jsonDocument = database.Get(BackupStatus.RavenBackupStatusDocumentKey, null);
if (jsonDocument == null)
{
return;
}
var backupStatus = jsonDocument.DataAsJson.JsonDeserialization <BackupStatus>();
backupStatus.IsRunning = false;
backupStatus.Completed = SystemTime.UtcNow;
database.Put(BackupStatus.RavenBackupStatusDocumentKey, null, RavenJObject.FromObject(backupStatus),
jsonDocument.Metadata,
null);
}
catch (Exception e)
{
logger.WarnException("Failed to update completed backup status, will try deleting document", e);
try
{
database.Delete(BackupStatus.RavenBackupStatusDocumentKey, null, null);
}
catch (Exception ex)
{
logger.WarnException("Failed to remove out of date backup status", ex);
}
}
}
public static void Execute(this ICommandData self, DocumentDatabase database)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag, patchCommandData.Patches, patchCommandData.TransactionInformation);
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
}
return;
}
}
public void AfterDeletingAndStoringTheDocumentIsIndexed()
{
db.PutIndex(@"DocsByProject", new IndexDefinition
{
Map = @"from doc in docs select new{ doc.Something}"
});
db.Put("foos/1", null, RavenJObject.Parse("{'Something':'something'}"),
RavenJObject.Parse("{'Raven-Entity-Name': 'Foos'}"), null);
var document = db.Get("foos/1", null);
db.Delete("foos/1", document.Etag, null);
db.Put("foos/1", null, RavenJObject.Parse("{'Something':'something'}"),
RavenJObject.Parse("{'Raven-Entity-Name': 'Foos'}"), null);
QueryResult queryResult;
do
{
queryResult = db.Query("Raven/DocumentsByEntityName", new IndexQuery
{
Query = "Tag:[[Foos]]",
PageSize = 10
});
} while (queryResult.IsStale);
Assert.Equal(1, queryResult.TotalResults);
}
public void Can_delete_document()
{
db.Put("1", Guid.Empty, RavenJObject.Parse("{ first_name: 'ayende', last_name: 'rahien'}"), new RavenJObject(), null);
var document = db.Get("1", null);
db.Delete("1", document.Etag, null);
Assert.Null(db.Get("1", null));
}
public RavenJArray DeleteByIndex(string indexName, IndexQuery queryToDelete, bool allowStale)
{
return(PerformBulkOperation(indexName, queryToDelete, allowStale, (docId, tx) =>
{
database.Delete(docId, null, tx);
return new { Document = docId, Deleted = true };
}));
}
public static void Execute(this ICommandData self, DocumentDatabase database)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag, patchCommandData.Patches, patchCommandData.TransactionInformation);
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
}
return;
}
var advPatchCommandData = self as ScriptedPatchCommandData;
if (advPatchCommandData != null)
{
var result = database.ApplyPatch(advPatchCommandData.Key, advPatchCommandData.Etag,
advPatchCommandData.Patch, advPatchCommandData.TransactionInformation, advPatchCommandData.DebugMode);
if (advPatchCommandData.DebugMode)
{
advPatchCommandData.AdditionalData = result.Item1.Document;
return;
}
var doc = database.Get(advPatchCommandData.Key, advPatchCommandData.TransactionInformation);
if (doc != null)
{
advPatchCommandData.Metadata = doc.Metadata;
advPatchCommandData.Etag = doc.Etag;
}
return;
}
}
public override void Dispose()
{
var patcher = new ScriptedIndexResultsJsonPatcher(database, forEntityNames);
if (string.IsNullOrEmpty(scriptedIndexResults.DeleteScript) == false)
{
foreach (var removeKey in removed)
{
patcher.Apply(new RavenJObject(), new ScriptedPatchRequest
{
Script = scriptedIndexResults.DeleteScript,
Values =
{
{ "key", removeKey }
}
});
}
}
if (string.IsNullOrEmpty(scriptedIndexResults.IndexScript) == false)
{
foreach (var kvp in created)
{
try
{
patcher.Apply(kvp.Value, new ScriptedPatchRequest
{
Script = scriptedIndexResults.IndexScript,
Values =
{
{ "key", kvp.Key }
}
});
}
catch (Exception e)
{
log.Warn("Could not apply index script " + scriptedIndexResults.Id + " to index result with key: " + kvp.Key, e);
}
}
}
database.TransactionalStorage.Batch(accessor =>
{
if (patcher.CreatedDocs != null)
{
foreach (var jsonDocument in patcher.CreatedDocs)
{
patcher.DocumentsToDelete.Remove(jsonDocument.Key);
database.Put(jsonDocument.Key, jsonDocument.Etag, jsonDocument.DataAsJson, jsonDocument.Metadata, null);
}
}
foreach (var doc in patcher.DocumentsToDelete)
{
database.Delete(doc, null, null);
}
});
}
public void CanCascadeDeletes()
{
db.Put("abc", null, JObject.Parse("{name: 'a'}"), JObject.Parse("{'Cascade-Delete': 'def'}"), null);
db.Put("def", null, JObject.Parse("{name: 'b'}"), new JObject(), null);
db.Delete("abc", null, null);
Assert.Null(db.Get("def", null));
}
private void ActivatePendingDocuments()
{
using (_database.DisableAllTriggersForCurrentThread())
{
var revisionKeys = PendingRevisionsIndex.GetRevisionsRequiringActivation(_database);
foreach (var revisionkey in revisionKeys)
{
_log.Info("Activating Temporal Document {0}", revisionkey);
// Establish a new transaction
var transactionInformation = new TransactionInformation {
Id = Guid.NewGuid().ToString(), Timeout = TimeSpan.FromMinutes(1)
};
// Get the current key from the revision key
var currentKey = revisionkey.Substring(0, revisionkey.IndexOf(TemporalConstants.TemporalKeySeparator, StringComparison.Ordinal));
// Mark the document as non-pending
_database.SetDocumentMetadata(revisionkey, transactionInformation, TemporalMetadata.RavenDocumentTemporalPending, false);
// Mark it in the history also
Etag historyEtag;
var history = _database.GetTemporalHistoryFor(currentKey, transactionInformation, out historyEtag);
history.Revisions.First(x => x.Key == revisionkey).Pending = false;
_database.SaveTemporalHistoryFor(currentKey, history, transactionInformation, historyEtag);
// Load the new revisions document
var newRevisionDoc = _database.Get(revisionkey, transactionInformation);
var temporal = newRevisionDoc.Metadata.GetTemporalMetadata();
if (temporal.Deleted)
{
// When the revision is a deletion, delete the current document
_database.Delete(currentKey, null, transactionInformation);
}
else
{
// Prepare the current document metadata
newRevisionDoc.Metadata.Remove(TemporalMetadata.RavenDocumentTemporalDeleted);
newRevisionDoc.Metadata.Remove(TemporalMetadata.RavenDocumentTemporalPending);
newRevisionDoc.Metadata.Remove("@id");
temporal.Status = TemporalStatus.Current;
temporal.RevisionNumber = int.Parse(newRevisionDoc.Key.Split('/').Last());
// Copy the revision to the current document
_database.Put(currentKey, null, newRevisionDoc.DataAsJson, newRevisionDoc.Metadata, transactionInformation);
}
// Commit the transaction
_database.Commit(transactionInformation.Id);
}
}
}
private void ResetFailureCount(string url, string lastError)
{
var failureCount = replicationFailureStats.GetOrAdd(url);
Interlocked.Exchange(ref failureCount.Count, 0);
failureCount.Timestamp = SystemTime.UtcNow;
if (string.IsNullOrWhiteSpace(lastError) == false)
{
failureCount.LastError = lastError;
}
docDb.Delete(Constants.RavenReplicationDestinationsBasePath + EscapeDestinationName(url), null,
null);
}
public void Execute(DocumentDatabase database)
{
var oldBackup = database.Get(BackupStatus.RavenBackupStatusDocumentKey,null);
if (oldBackup == null)
return;
var backupStatus = oldBackup.DataAsJson.JsonDeserialization<BackupStatus>();
if (backupStatus.Completed != null) // keep the record of the last successful backup
return;
database.Delete(BackupStatus.RavenBackupStatusDocumentKey, null, null);
}
public void Execute(DocumentDatabase database)
{
if (database.Name != SpecificDatabaseName)
{
return;
}
bool stale;
var queryResults = database.QueryDocumentIds("Notifications/Temp", new IndexQuery(), out stale);
foreach (var documentId in queryResults)
{
database.Delete(documentId, null, null);
}
}
public async Task DeleteTest()
{
Database3 = new DocumentDatabase(new IndexModel("bin_stor2", "bin_stor2"));
foreach (var d in DocumentModel)
{
await Database3.Insert(d);
}
var model = DocumentModel.First();
await Database3.Delete(model);
var actual = await Database3.Find(model.Id);
Assert.IsNull(actual);
}
public void CanDelete()
{
var values = new[]
{
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{},{},{},{}]}",
"{blog_id: 6, comments: [{},{},{},{},{},{}]}",
"{blog_id: 7, comments: [{}]}",
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 3, comments: [{},{},{},{},{}]}",
"{blog_id: 2, comments: [{},{},{},{},{},{},{},{}]}",
"{blog_id: 4, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{},{}]}",
"{blog_id: 3, comments: [{},{},{}]}",
"{blog_id: 5, comments: [{}]}",
};
for (int i = 0; i < values.Length; i++)
{
db.Put("docs/" + i, null, JObject.Parse(values[i]), new JObject(), null);
}
QueryResult q = null;
while (db.HasTasks)
{
Thread.Sleep(100);
}
db.Delete("docs/0", null, null);
for (var i = 0; i < 5; i++)
{
do
{
q = db.Query("CommentsCountPerBlog", new IndexQuery
{
Query = "blog_id:3",
Start = 0,
PageSize = 10
});
Thread.Sleep(100);
} while (q.IsStale);
}
Assert.Equal(@"{""blog_id"":""3"",""comments_length"":""11""}", q.Results[0].ToString(Formatting.None));
}
public void Execute(DocumentDatabase database)
{
var oldBackup = database.Get(BackupStatus.RavenBackupStatusDocumentKey, null);
if (oldBackup == null)
{
return;
}
var backupStatus = oldBackup.DataAsJson.JsonDeserialization <BackupStatus>();
if (backupStatus.Completed != null) // keep the record of the last successful backup
{
return;
}
database.Delete(BackupStatus.RavenBackupStatusDocumentKey, null, null);
}
private void UpdateSkippedCheck()
{
lastCheck = DateTime.UtcNow;
var totalSizeOnDisk = database.GetTotalSizeOnDisk();
if (totalSizeOnDisk <= softLimit)
{
database.Delete("Raven/Quotas/Size", null, null);
skipCheck = VetoResult.Allowed;
recheckOnDelete = false;
return;
}
recheckOnDelete = true;
string msg;
if (totalSizeOnDisk > hardLimit) // beyond the grace margin
{
msg = string.Format("Database size is {0:#,#} KB, which is over the allowed quota of {1:#,#} KB. No more documents are allowed in.",
totalSizeOnDisk / 1024, hardLimit / 1024);
database.Put("Raven/Quotas/Size", null, new RavenJObject
{
{ "Message", msg }
}, new RavenJObject(), null);
skipCheck = VetoResult.Deny(msg);
}
else // still before the hard limit, warn, but allow
{
msg = string.Format("Database size is {0:#,#} KB, which is close to the allowed quota of {1:#,#} KB",
totalSizeOnDisk / 1024, softLimit / 1024);
database.Put("Raven/Quotas/Size", null, new RavenJObject
{
{ "Message", msg }
}, new RavenJObject(), null);
skipCheck = VetoResult.Allowed;
}
}
private void UpdateSkippedCheck()
{
lastCheck = DateTime.UtcNow;
var countOfDocuments = database.Statistics.CountOfDocuments;
if (countOfDocuments <= softLimit)
{
database.Delete("Raven/Quotas/Documents", null, null);
skipCheck = VetoResult.Allowed;
recheckOnDelete = false;
return;
}
recheckOnDelete = true;
string msg;
if (countOfDocuments > hardLimit) // beyond the grace margin
{
msg = string.Format("Database doc count is {0:#,#}, which is over the allowed quota of {1:#,#}. No more documents are allowed in.",
countOfDocuments, hardLimit);
database.Put("Raven/Quotas/Documents", null, new RavenJObject
{
{ "Message", msg }
}, new RavenJObject(), null);
skipCheck = VetoResult.Deny(msg);
}
else // still before the hard limit, warn, but allow
{
msg = string.Format("Database doc count is {0:#,#}, which is close to the allowed quota of {1:#,#}.",
countOfDocuments, softLimit);
database.Put("Raven/Quotas/Documents", null, new RavenJObject
{
{ "Message", msg }
}, new RavenJObject(), null);
skipCheck = VetoResult.Allowed;
}
}
private void SetupReplication()
{
if (RoleEnvironment.CurrentRoleInstance.Role.Instances.Count < 2)
{
var tr = new TransactionInformation();
_database.Put("Debug", null,
JObject.Parse(@"{""Url"":""" +
GetEndPointAddress(MyInstanceEndpoint.IPEndpoint) + @"""}"),
new JObject(), tr);
_database.Commit(tr.Id);
}
else
{
var json = BuildDestinationsString();
Trace.WriteLine(json);
var tr = new TransactionInformation();
_database.Delete("Raven/Replication/Destinations", null, tr);
_database.Put("Raven/Replication/Destinations", null, JObject.Parse(json),
new JObject(), tr);
_database.Commit(tr.Id);
}
}
public void Execute(DocumentDatabase database)
{
database.Delete(Key, Etag, TransactionInformation);
}
public void Execute(DocumentDatabase database)
{
if (database.Name != SpecificDatabaseName)
return;
bool stale;
var queryResults = database.QueryDocumentIds("Notifications/Temp", new IndexQuery(), out stale);
foreach (var documentId in queryResults)
{
database.Delete(documentId, null, null);
}
}
public void Delete(string key, Guid?etag)
{
database.Delete(key, etag, GetTransactionInformation());
}
public void Execute(DocumentDatabase database)
{
database.Delete("Raven/Backup/Status", null, null);
}
private void ResetFailureCount(ReplicationStrategy destination)
{
docDb.Delete(ReplicationConstants.RavenReplicationDestinationsBasePath + EscapeDestinationName(destination), null,
null);
}
/// <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());
}
private static void Execute(ICommandData self, DocumentDatabase database, BatchResult batchResult)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
var result = database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
if (batchResult != null)
{
batchResult.Deleted = result;
}
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
var result = database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag,
patchCommandData.Patches, patchCommandData.PatchesIfMissing, patchCommandData.Metadata,
patchCommandData.TransactionInformation);
if (batchResult != null)
{
batchResult.PatchResult = result.PatchResult;
}
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
});
}
return;
}
var advPatchCommandData = self as ScriptedPatchCommandData;
if (advPatchCommandData != null)
{
var result = database.ApplyPatch(advPatchCommandData.Key, advPatchCommandData.Etag,
advPatchCommandData.Patch, advPatchCommandData.PatchIfMissing, advPatchCommandData.Metadata,
advPatchCommandData.TransactionInformation, advPatchCommandData.DebugMode);
if (batchResult != null)
{
batchResult.PatchResult = result.Item1.PatchResult;
}
advPatchCommandData.AdditionalData = new RavenJObject {
{ "Debug", new RavenJArray(result.Item2) }
};
if (advPatchCommandData.DebugMode)
{
advPatchCommandData.AdditionalData["Document"] = result.Item1.Document;
return;
}
var doc = database.Get(advPatchCommandData.Key, advPatchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
advPatchCommandData.Metadata = doc.Metadata;
advPatchCommandData.Etag = doc.Etag;
});
}
return;
}
}
/// <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, TransactionInformation);
}
public void Execute(DocumentDatabase database)
{
database.Delete(Key, Etag, TransactionInformation);
}
public void Execute(DocumentDatabase database)
{
database.Delete("Raven/Backup/Status", null, null);
}
private static void Execute(ICommandData self, DocumentDatabase database, BatchResult batchResult)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
var result = database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
if (batchResult != null)
batchResult.Deleted = result;
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
var result = database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag,
patchCommandData.Patches, patchCommandData.PatchesIfMissing, patchCommandData.Metadata,
patchCommandData.TransactionInformation);
if (batchResult != null)
batchResult.PatchResult = result.PatchResult;
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
});
}
return;
}
var advPatchCommandData = self as ScriptedPatchCommandData;
if (advPatchCommandData != null)
{
var result = database.ApplyPatch(advPatchCommandData.Key, advPatchCommandData.Etag,
advPatchCommandData.Patch, advPatchCommandData.PatchIfMissing, advPatchCommandData.Metadata,
advPatchCommandData.TransactionInformation, advPatchCommandData.DebugMode);
if (batchResult != null)
batchResult.PatchResult = result.Item1.PatchResult;
advPatchCommandData.AdditionalData = new RavenJObject { { "Debug", new RavenJArray(result.Item2) } };
if(advPatchCommandData.DebugMode)
{
advPatchCommandData.AdditionalData["Document"] = result.Item1.Document;
return;
}
var doc = database.Get(advPatchCommandData.Key, advPatchCommandData.TransactionInformation);
if (doc != null)
{
database.TransactionalStorage.ExecuteImmediatelyOrRegisterForSynchronization(() =>
{
advPatchCommandData.Metadata = doc.Metadata;
advPatchCommandData.Etag = doc.Etag;
});
}
return;
}
}
