private void HandleBatchOfRevisionsIfNecessary()
            {
                var prevDoneAndHasEnough = _revisionDeleteCommand.Context.AllocatedMemory > Constants.Size.Megabyte && _prevRevisionCommandTask.IsCompleted;
                var currentReachedLimit  = _revisionDeleteCommand.Context.AllocatedMemory > _enqueueThreshold.GetValue(SizeUnit.Bytes);

                if (currentReachedLimit == false && prevDoneAndHasEnough == false)
                {
                    return;
                }

                var prevCommand     = _prevRevisionDeleteCommand;
                var prevCommandTask = _prevRevisionCommandTask;
                var commandTask     = _database.TxMerger.Enqueue(_revisionDeleteCommand);

                // we ensure that we first enqueue the command to if we
                // fail to do that, we won't be waiting on the previous
                // one
                _prevRevisionDeleteCommand = _revisionDeleteCommand;
                _prevRevisionCommandTask   = commandTask;

                if (prevCommand != null)
                {
                    using (prevCommand)
                    {
                        prevCommandTask.GetAwaiter().GetResult();
                        Debug.Assert(prevCommand.IsDisposed == false,
                                     "we rely on reusing this context on the next batch, so it has to be disposed here");
                    }
                }

                _revisionDeleteCommand = new MergedBatchDeleteRevisionCommand(_database, _log);
            }
            private void DeleteRevisionsForNonExistingDocuments()
            {
                if (_missingDocumentsForRevisions == null)
                {
                    return;
                }

                _revisionDeleteCommand = new MergedBatchDeleteRevisionCommand(_database, _log);

                foreach (var docId in _missingDocumentsForRevisions)
                {
                    _revisionDeleteCommand.Add(docId);
                    HandleBatchOfRevisionsIfNecessary();
                }
                FinishBatchOfRevisions();
            }
            private void FinishBatchOfRevisions()
            {
                if (_prevRevisionDeleteCommand != null)
                {
                    using (_prevRevisionDeleteCommand)
                        AsyncHelpers.RunSync(() => _prevRevisionCommandTask);

                    _prevRevisionDeleteCommand = null;
                }

                if (_revisionDeleteCommand.Ids.Count > 0)
                {
                    using (_revisionDeleteCommand)
                        AsyncHelpers.RunSync(() => _database.TxMerger.Enqueue(_revisionDeleteCommand));
                }

                _revisionDeleteCommand = null;
            }