C# DocumentDatabase.Get方法代码示例

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

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