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 ScriptedJsonPatcher(DocumentDatabase database = null)
{
if (database == null)
{
maxSteps = 10 * 1000;
additionalStepsPerSize = 5;
loadDocument = (s =>
{
throw new InvalidOperationException(
"Cannot load by id without database context");
});
}
else
{
maxSteps = database.Configuration.MaxStepsForScript;
additionalStepsPerSize = database.Configuration.AdditionalStepsForScriptBasedOnDocumentSize;
loadDocument = id =>
{
JsonDocument jsonDocument;
if (!createdDocDict.TryGetValue(id, out jsonDocument))
jsonDocument = database.Get(id, null);
return jsonDocument == null ? null : jsonDocument.ToJson();
};
}
}
public void Execute(DocumentDatabase database)
{
database.ApplyPatch(Key, Etag, Patches, TransactionInformation);
var doc = database.Get(Key, TransactionInformation);
if (doc != null)
Metadata = doc.Metadata;
}
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 static void RemoveWarnings(DocumentDatabase db, string prefix)
{
var document = db.Get("Raven/WarningMessages", null);
WarningMessagesHolder messagesHolder = document == null
? new WarningMessagesHolder()
: document.DataAsJson.JsonDeserialization<WarningMessagesHolder>();
// remove anything else with this prefix
var removed = messagesHolder.Messages.RemoveWhere(x => x.StartsWith(prefix) );
if (removed == 0)
return;
db.Put("Raven/WarningMessages", null,
RavenJObject.FromObject(messagesHolder),
new RavenJObject(), null);
}
public ScriptedJsonPatcher(DocumentDatabase database = null)
{
if (database == null)
{
loadDocument = (s =>
{
throw new InvalidOperationException(
"Cannot load by id without database context");
});
}
else
{
loadDocument = id =>
{
var jsonDocument = database.Get(id, null);
return jsonDocument == null ? null : jsonDocument.ToJson();
};
}
}
public void Execute(DocumentDatabase database)
{
Database = database;
// Not having a setup doc means this DB isn't enabled for periodic backups
var document = Database.Get(PeriodicBackupSetup.RavenDocumentKey, null);
if (document == null)
return;
var backupConfigs = document.DataAsJson.JsonDeserialization<PeriodicBackupSetup>();
if (backupConfigs.Interval <= 0)
return;
awsAccessKey = Database.Configuration.Settings["Raven/AWSAccessKey"];
awsSecretKey = Database.Configuration.Settings["Raven/AWSSecretKey"];
interval = backupConfigs.Interval;
logger.Info("Periodic backups started, will backup every" + interval + "minutes");
timer = new Timer(TimerCallback, null, TimeSpan.FromMinutes(interval), TimeSpan.FromMinutes(interval));
}
public static void AddWarning(DocumentDatabase db, string prefix, string msg)
{
var document = db.Get("Raven/WarningMessages", null);
WarningMessagesHolder messagesHolder = document == null
? new WarningMessagesHolder()
: document.DataAsJson.JsonDeserialization<WarningMessagesHolder>();
var message = prefix + ": " + msg;
if (messagesHolder.Messages.Add(message) == false)
{
return; //already there
}
// remove anything else with this prefix
messagesHolder.Messages.RemoveWhere(x => x.StartsWith(prefix) && x != message);
db.Put("Raven/WarningMessages", null,
RavenJObject.FromObject(messagesHolder),
new RavenJObject(), null);
}
public ScriptedJsonPatcher(DocumentDatabase database = null)
{
if (database == null)
{
maxSteps = 10 * 1000;
additionalStepsPerSize = 5;
loadDocument = (s =>
{
throw new InvalidOperationException(
"Cannot load by id without database context");
});
}
else
{
maxSteps = database.Configuration.MaxStepsForScript;
additionalStepsPerSize = database.Configuration.AdditionalStepsForScriptBasedOnDocumentSize;
loadDocument = id =>
{
var jsonDocument = database.Get(id, null);
return jsonDocument == null ? null : jsonDocument.ToJson();
};
}
propertiesTypeByName = new Dictionary<string, JTokenType>();
}
/// <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()));
}
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;
}
}
public override void OnIndexEntryCreated(string entryKey, Document document)
{
var resultDocId = document.GetField(setupDoc.DocumentKey);
if (resultDocId == null)
{
log.Warn("Could not find document id property '{0}' in '{1}' for index '{2}'", setupDoc.DocumentKey, entryKey, index);
return;
}
var documentId = resultDocId.StringValue;
itemsToRemove.TryRemove(documentId);
var resultDoc = database.Get(documentId, null);
if (resultDoc == null)
{
log.Warn("Could not find a document with the id '{0}' for index '{1}'", documentId, index);
return;
}
var entityName = resultDoc.Metadata.Value <string>(Constants.RavenEntityName);
if (entityName != null && viewGenerator.ForEntityNames.Contains(entityName))
{
log.Warn(
"Rejected update for a potentially recursive update on document '{0}' because the index '{1}' includes documents with entity name of '{2}'",
documentId, index, entityName);
return;
}
if (viewGenerator.ForEntityNames.Count == 0)
{
log.Warn(
"Rejected update for a potentially recursive update on document '{0}' because the index '{1}' includes all documents",
documentId, index);
return;
}
var changesMade = false;
foreach (var mapping in setupDoc.FieldNameMappings)
{
var field =
document.GetFieldable(mapping.Key + "_Range") ??
document.GetFieldable(mapping.Key);
if (field == null)
{
continue;
}
var numericField = field as NumericField;
if (numericField != null)
{
resultDoc.DataAsJson[mapping.Value] = new RavenJValue(numericField.NumericValue);
}
else if (field.IsBinary == false)
{
resultDoc.DataAsJson[mapping.Value] = GetStringValue(field);
}
changesMade = true;
}
if (changesMade)
{
database.Put(documentId, resultDoc.Etag, resultDoc.DataAsJson, resultDoc.Metadata, null);
}
}
public void PutTwoDocumentsAndThenCommit()
{
var transactionInformation = new TransactionInformation {
Id = Guid.NewGuid(), Timeout = TimeSpan.FromMinutes(1)
};
db.Put("ayende1", null, RavenJObject.Parse("{ayende:'rahien'}"), new RavenJObject(), transactionInformation);
db.Put("ayende2", null, RavenJObject.Parse("{ayende:'rahien'}"), new RavenJObject(), transactionInformation);
db.Commit(transactionInformation.Id);
Assert.NotNull(db.Get("ayende1", null));
Assert.NotNull(db.Get("ayende2", null));
}
public void CanPutDocumentWithLowerCaseName()
{
db.Put("abc", null, JObject.Parse("{'name': 'abc'}"), new JObject(), null);
Assert.Contains("\"name\":\"abc\"", db.Get("abc", null).ToJson().ToString(Formatting.None));
}
public void Can_get_id_from_document_metadata()
{
db.Put("1", Etag.Empty, RavenJObject.Parse("{ first_name: 'ayende', last_name: 'rahien'}"),
new RavenJObject(), null);
Assert.Equal("1", db.Get("1", null).Metadata["@id"].Value <string>());
}
public void PutNewDocInTxCommitAndThenGetIt()
{
var transactionInformation = new TransactionInformation {
Id = Guid.NewGuid(), Timeout = TimeSpan.FromMinutes(1)
};
db.Put("ayende", null, JObject.Parse("{ayende:'rahien'}"), new JObject(), transactionInformation);
db.Commit(transactionInformation.Id);
Assert.NotNull(db.Get("ayende", null));
}
protected void WaitForBackup(DocumentDatabase db, bool checkError)
{
WaitForBackup(key => db.Get(key, null), checkError);
}
public dynamic LoadDocument(string key)
{
if (key == null)
{
return(new DynamicNullObject());
}
var source = Source;
if (source == null)
{
throw new ArgumentException(
"LoadDocument can only be called as part of the Map stage of the index, but was called with " + key +
" without a source.");
}
var id = source.__document_id as string;
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException(
"LoadDocument can only be called as part of the Map stage of the index, but was called with " + key +
" without a document. Current source: " + source);
}
if (string.Equals(key, id))
{
return(source);
}
HashSet <string> set;
if (referencedDocuments.TryGetValue(id, out set) == false)
{
referencedDocuments.Add(id, set = new HashSet <string>(StringComparer.OrdinalIgnoreCase));
}
set.Add(key);
dynamic value;
if (docsCache.TryGetValue(key, out value))
{
return(value);
}
var doc = database.Get(key, null);
if (doc == null)
{
log.Debug("Loaded document {0} by document {1} for index {2} could not be found", key, id, index);
referencesEtags.Add(key, Etag.Empty);
value = new DynamicNullObject();
}
else
{
log.Debug("Loaded document {0} with etag {3} by document {1} for index {2}\r\n{4}", key, id, index, doc.Etag, doc.ToJson());
referencesEtags.Add(key, doc.Etag);
value = new DynamicJsonObject(doc.ToJson());
}
docsCache[key] = value;
return(value);
}
public MoreLikeThisQueryResult ExecuteMoreLikeThisQuery(MoreLikeThisQuery query, TransactionInformation transactionInformation, int pageSize = 25, string[] include = null)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
var index = database.IndexStorage.GetIndexInstance(query.IndexName);
if (index == null)
{
throw new InvalidOperationException("The index " + query.IndexName + " cannot be found");
}
if (string.IsNullOrEmpty(query.DocumentId) && query.MapGroupFields.Count == 0)
{
throw new InvalidOperationException("The document id or map group fields are mandatory");
}
IndexSearcher searcher;
using (database.IndexStorage.GetCurrentIndexSearcher(query.IndexName, out searcher))
{
var documentQuery = new BooleanQuery();
if (string.IsNullOrEmpty(query.DocumentId) == false)
{
documentQuery.Add(new TermQuery(new Term(Constants.DocumentIdFieldName, query.DocumentId.ToLowerInvariant())), Occur.MUST);
}
foreach (string key in query.MapGroupFields.Keys)
{
documentQuery.Add(new TermQuery(new Term(key, query.MapGroupFields[key])), Occur.MUST);
}
var td = searcher.Search(documentQuery, 1);
// get the current Lucene docid for the given RavenDB doc ID
if (td.ScoreDocs.Length == 0)
{
throw new InvalidOperationException("Document " + query.DocumentId + " could not be found");
}
var ir = searcher.IndexReader;
var mlt = new RavenMoreLikeThis(ir);
AssignParameters(mlt, query);
if (string.IsNullOrWhiteSpace(query.StopWordsDocumentId) == false)
{
var stopWordsDoc = database.Get(query.StopWordsDocumentId, null);
if (stopWordsDoc == null)
{
throw new InvalidOperationException("Stop words document " + query.StopWordsDocumentId + " could not be found");
}
var stopWordsSetup = stopWordsDoc.DataAsJson.JsonDeserialization <StopWordsSetup>();
if (stopWordsSetup.StopWords != null)
{
var stopWords = stopWordsSetup.StopWords;
var ht = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
foreach (var stopWord in stopWords)
{
ht[stopWord] = stopWord;
}
mlt.SetStopWords(ht);
}
}
var fieldNames = query.Fields ?? GetFieldNames(ir);
mlt.SetFieldNames(fieldNames);
var toDispose = new List <Action>();
RavenPerFieldAnalyzerWrapper perFieldAnalyzerWrapper = null;
try
{
perFieldAnalyzerWrapper = index.CreateAnalyzer(new LowerCaseKeywordAnalyzer(), toDispose, true);
mlt.SetAnalyzer(perFieldAnalyzerWrapper);
var mltQuery = mlt.Like(td.ScoreDocs[0].Doc);
var tsdc = TopScoreDocCollector.Create(pageSize, true);
searcher.Search(mltQuery, tsdc);
var hits = tsdc.TopDocs().ScoreDocs;
var jsonDocuments = GetJsonDocuments(query, searcher, index, query.IndexName, hits, td.ScoreDocs[0].Doc);
var result = new MultiLoadResult();
var includedEtags = new List <byte>(jsonDocuments.SelectMany(x => x.Etag.Value.ToByteArray()));
includedEtags.AddRange(database.GetIndexEtag(query.IndexName, null).ToByteArray());
var loadedIds = new HashSet <string>(jsonDocuments.Select(x => x.Key));
var addIncludesCommand = new AddIncludesCommand(database, transactionInformation, (etag, includedDoc) =>
{
includedEtags.AddRange(etag.ToByteArray());
result.Includes.Add(includedDoc);
}, include ?? new string[0], loadedIds);
foreach (var jsonDocument in jsonDocuments)
{
result.Results.Add(jsonDocument.ToJson());
addIncludesCommand.Execute(jsonDocument.DataAsJson);
}
Guid computedEtag;
using (var md5 = MD5.Create())
{
var computeHash = md5.ComputeHash(includedEtags.ToArray());
computedEtag = new Guid(computeHash);
}
return(new MoreLikeThisQueryResult
{
Etag = computedEtag,
Result = result,
});
}
finally
{
if (perFieldAnalyzerWrapper != null)
{
perFieldAnalyzerWrapper.Close();
}
foreach (var action in toDispose)
{
action();
}
}
}
}
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;
}
}
