C# DocumentDatabase.Put方法代码示例

		public void ShouldNotSetAutoIndexesToAbandonedPriorityAfterDatabaseRecovery()
		{
			using (var db = new DocumentDatabase(new RavenConfiguration
			{
				DataDirectory = DataDir,
				RunInUnreliableYetFastModeThatIsNotSuitableForProduction = false
			}))
			{
				db.SpinBackgroundWorkers();
				db.PutIndex(new RavenDocumentsByEntityName().IndexName, new RavenDocumentsByEntityName().CreateIndexDefinition());

				db.Put("users/1", null, RavenJObject.Parse("{'Name':'Arek'}"), RavenJObject.Parse("{'Raven-Entity-Name':'Users'}"), null);
				db.Put("users/2", null, RavenJObject.Parse("{'Name':'David'}"), RavenJObject.Parse("{'Raven-Entity-Name':'Users'}"), null);

				var results = db.ExecuteDynamicQuery("Users", new IndexQuery()
				{
					PageSize = 128,
					Start = 0,
					Cutoff = SystemTime.UtcNow,
					Query = "Name:Arek"
				}, CancellationToken.None);

				WaitForIndexing(db);

				var autoIdexes = db.Statistics.Indexes.Where(x => x.Name.StartsWith("Auto")).ToList();

				Assert.True(autoIdexes.Count > 0);

				autoIdexes.ForEach(x => db.TransactionalStorage.Batch(accessor => accessor.Indexing.SetIndexPriority(x.Name, IndexingPriority.Idle)));
				
				db.StartBackup(BackupDir, false, new DatabaseDocument());
				WaitForBackup(db, true);
			}
			IOExtensions.DeleteDirectory(DataDir);

			DocumentDatabase.Restore(new RavenConfiguration(), BackupDir, DataDir, s => { }, defrag: true);

			using (var db = new DocumentDatabase(new RavenConfiguration
			{
				DataDirectory = DataDir,
				RunInUnreliableYetFastModeThatIsNotSuitableForProduction = false,
			}))
			{
				db.SpinBackgroundWorkers();
				db.RunIdleOperations();

				var autoIndexes = db.Statistics.Indexes.Where(x => x.Name.StartsWith("Auto")).ToList();

				Assert.True(autoIndexes.Count > 0);

				foreach (var indexStats in autoIndexes)
				{
					Assert.NotEqual(indexStats.Priority, IndexingPriority.Abandoned);
				}
			}
		}

        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 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 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 void Execute(DocumentDatabase database)
 {
     var putResult = database.Put(Key, Etag, Document, Metadata, TransactionInformation);
     Etag = putResult.ETag;
     Key = putResult.Key;
 }

		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;
			}
		}