public Tuple<List<BsonDocument>, int, Stack<string>> Execute(List<string> jsonDocument, int maxInPageCount, int pageNumber, int resultCount) { var log = new Stack<string>(); var list = new List<BsonDocument>(); foreach (var document in jsonDocument) { var documentBson = BsonDocument.Parse(document); list.Add(documentBson); } if (pageNumber == 0 && pageNumber != -1) { var tmp = BuildCountQuery(list); resultCount = tmp.Item1; log.Push(tmp.Item2); } if (maxInPageCount != -1) { // Tacke the currentPage long skip = maxInPageCount * pageNumber; list = AddSkipAndTackeStages(list, skip, maxInPageCount); } var option = new AggregateOptions() { AllowDiskUse = true }; var statTime = DateTime.Now.Ticks; var result = _collection.Aggregate<BsonDocument>(list, option).ToList(); var endDate = DateTime.Now.Ticks; var duration = endDate - statTime; var resultDuration = TimeSpan.FromTicks(duration).TotalSeconds; log.Push(string.Format("{0} - {1} : Duration (s) {2} ", TimeSpan.FromTicks( statTime).ToString(), BuildStringQuery(list.Select(p => p.ToString()).ToArray()), resultDuration)); return new Tuple<List<BsonDocument>, int, Stack<string>>(result, resultCount,log); }
public MongoDbAggregateOperationViewModel(TabViewModel owner) : base(owner) { Name = Constants.AggregateOperation; DisplayName = "Aggregate"; AggregateOptions = new AggregateOptions(); ExecuteAggregate = new RelayCommand(InnerExecuteAggregate); }
// private methods private AggregateOperation <TResult> CreateAggregateOperation <TResult>(RenderedPipelineDefinition <TResult> renderedPipeline, AggregateOptions options) { var messageEncoderSettings = GetMessageEncoderSettings(); return(new AggregateOperation <TResult>( _databaseNamespace, renderedPipeline.Documents, renderedPipeline.OutputSerializer, messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, Collation = options.Collation, Comment = options.Comment, Hint = options.Hint, MaxAwaitTime = options.MaxAwaitTime, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern, RetryRequested = _client.Settings.RetryReads, UseCursor = options.UseCursor }); }
public async Task<List<BsonDocument>> AggregateAsync(string databaseName, string collectionName, BsonArray pipeline, AggregateOptions options, bool explain, CancellationToken token) { return await Task.Run(() => { var server = client.GetServer(); var database = server.GetDatabase(databaseName); var collection = database.GetCollection(collectionName); List<BsonDocument> result; if (!explain) result = collection.Aggregate(new AggregateArgs() { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, MaxTime = options.MaxTime, Pipeline = pipeline.Select(s => s.AsBsonDocument) }).ToList(); else { var explainResult = collection.AggregateExplain(new AggregateArgs() { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, MaxTime = options.MaxTime, Pipeline = pipeline.Select(s => s.AsBsonDocument) }); result = new List<BsonDocument>(); result.Add(explainResult.Response); } return result; }, token); }
// constructors public AggregateFluent(IClientSessionHandle session, IMongoCollection <TDocument> collection, PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options) { _session = session; // can be null _collection = Ensure.IsNotNull(collection, nameof(collection)); _pipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)); _options = Ensure.IsNotNull(options, nameof(options)); }
public override Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IClientSessionHandle session, PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { var filteredPipeline = CreateFilteredPipeline(pipeline); return(_wrappedCollection.AggregateAsync(session, filteredPipeline, options, cancellationToken)); }
/// <inheritdoc /> public virtual Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IClientSessionHandle session, PipelineDefinition <NoPipelineInput, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
// public methods public override IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken)) { return(UsingImplicitSession(session => Aggregate(session, pipeline, options, cancellationToken), cancellationToken)); }
public override void AggregateToCollection <TResult>(IClientSessionHandle session, PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { var filteredPipeline = CreateFilteredPipeline(pipeline); _wrappedCollection.AggregateToCollection(session, filteredPipeline, options, cancellationToken); }
// constructors public AggregateFluent(IMongoCollection <TDocument> collection, IEnumerable <object> pipeline, AggregateOptions options, IBsonSerializer <TResult> resultSerializer) { _collection = Ensure.IsNotNull(collection, "collection"); _pipeline = Ensure.IsNotNull(pipeline, "pipeline").ToList(); _options = Ensure.IsNotNull(options, "options"); _resultSerializer = resultSerializer; }
// constructors protected AggregateFluent(IClientSessionHandle session, PipelineDefinition <TInput, TResult> pipeline, AggregateOptions options) { _session = session; // can be null _pipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)); _options = Ensure.IsNotNull(options, nameof(options)); }
// public methods public override IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken) { var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(_documentSerializer, _settings.SerializerRegistry); options = options ?? new AggregateOptions(); var last = renderedPipeline.Documents.LastOrDefault(); if (last != null && last.GetElement(0).Name == "$out") { var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options); ExecuteWriteOperation(aggregateOperation, cancellationToken); // we want to delay execution of the find because the user may // not want to iterate the results at all... var findOperation = CreateAggregateToCollectionFindOperation(last, renderedPipeline.OutputSerializer, options); var deferredCursor = new DeferredAsyncCursor <TResult>( ct => ExecuteReadOperation(findOperation, ReadPreference.Primary, ct), ct => ExecuteReadOperationAsync(findOperation, ReadPreference.Primary, ct)); return(deferredCursor); } else { var aggregateOperation = CreateAggregateOperation(renderedPipeline, options); return(ExecuteReadOperation(aggregateOperation, cancellationToken)); } }
// constructors public AggregateFluent(IMongoCollection <TDocument> collection, IEnumerable <IPipelineStageDefinition> stages, AggregateOptions options) { _collection = Ensure.IsNotNull(collection, nameof(collection)); _stages = Ensure.IsNotNull(stages, nameof(stages)).ToList(); _options = Ensure.IsNotNull(options, nameof(options)); }
private AggregateToCollectionOperation CreateAggregateToCollectionOperation <TResult>(RenderedPipelineDefinition <TResult> renderedPipeline, AggregateOptions options) { return(new AggregateToCollectionOperation( _collectionNamespace, renderedPipeline.Documents, _messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, BypassDocumentValidation = options.BypassDocumentValidation, Collation = options.Collation, MaxTime = options.MaxTime, WriteConcern = _settings.WriteConcern }); }
private FindOperation <TResult> CreateAggregateToCollectionFindOperation <TResult>(BsonDocument outStage, IBsonSerializer <TResult> resultSerializer, AggregateOptions options) { var outputCollectionName = outStage.GetElement(0).Value.AsString; return(new FindOperation <TResult>( new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName), resultSerializer, _messageEncoderSettings) { BatchSize = options.BatchSize, Collation = options.Collation, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern }); }
private AggregateOperation <TResult> CreateAggregateOperation <TResult>(RenderedPipelineDefinition <TResult> renderedPipeline, AggregateOptions options) { return(new AggregateOperation <TResult>( _collectionNamespace, renderedPipeline.Documents, renderedPipeline.OutputSerializer, _messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, Collation = options.Collation, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern, UseCursor = options.UseCursor }); }
private FindOperation <TResult> CreateAggregateToCollectionFindOperation <TResult>(BsonDocument outStage, IBsonSerializer <TResult> resultSerializer, AggregateOptions options) { CollectionNamespace outputCollectionNamespace; var stageName = outStage.GetElement(0).Name; switch (stageName) { case "$out": { var outputCollectionName = outStage[0].AsString; outputCollectionNamespace = new CollectionNamespace(_databaseNamespace, outputCollectionName); } break; case "$merge": { var mergeArguments = outStage[0].AsBsonDocument; DatabaseNamespace outputDatabaseNamespace; string outputCollectionName; var into = mergeArguments["into"]; if (into.IsString) { outputDatabaseNamespace = _databaseNamespace; outputCollectionName = into.AsString; } else { outputDatabaseNamespace = new DatabaseNamespace(into["db"].AsString); outputCollectionName = into["coll"].AsString; } outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName); } break; default: throw new ArgumentException($"Unexpected stage name: {stageName}."); } // because auto encryption is not supported for non-collection commands. // So, an error will be thrown in the previous CreateAggregateToCollectionOperation step. // However, since we've added encryption configuration for CreateAggregateToCollectionOperation operation, // it's not superfluous to also add it here var messageEncoderSettings = GetMessageEncoderSettings(); return(new FindOperation <TResult>(outputCollectionNamespace, resultSerializer, messageEncoderSettings) { BatchSize = options.BatchSize, Collation = options.Collation, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern, RetryRequested = _client.Settings.RetryReads }); }
/// <inheritdoc /> public virtual IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
private AggregateToCollectionOperation CreateAggregateToCollectionOperation <TResult>(RenderedPipelineDefinition <TResult> renderedPipeline, AggregateOptions options) { var messageEncoderSettings = GetMessageEncoderSettings(); return(new AggregateToCollectionOperation( _databaseNamespace, renderedPipeline.Documents, messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, BypassDocumentValidation = options.BypassDocumentValidation, Collation = options.Collation, Comment = options.Comment, Hint = options.Hint, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern, WriteConcern = _settings.WriteConcern }); }
/// <inheritdoc /> public abstract Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
public override IAsyncCursor <TResult> Aggregate <TResult>(IClientSessionHandle session, PipelineDefinition <NoPipelineInput, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(session, nameof(session)); var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(NoPipelineInputSerializer.Instance, _settings.SerializerRegistry); options = options ?? new AggregateOptions(); var lastStage = renderedPipeline.Documents.LastOrDefault(); var lastStageName = lastStage?.GetElement(0).Name; if (lastStage != null && (lastStageName == "$out" || lastStageName == "$merge")) { var aggregateOperation = CreateAggregateToCollectionOperation(renderedPipeline, options); ExecuteWriteOperation(session, aggregateOperation, cancellationToken); // we want to delay execution of the find because the user may // not want to iterate the results at all... var findOperation = CreateAggregateToCollectionFindOperation(lastStage, renderedPipeline.OutputSerializer, options); var forkedSession = session.Fork(); var deferredCursor = new DeferredAsyncCursor <TResult>( () => forkedSession.Dispose(), ct => ExecuteReadOperation(forkedSession, findOperation, ReadPreference.Primary, ct), ct => ExecuteReadOperationAsync(forkedSession, findOperation, ReadPreference.Primary, ct)); return(deferredCursor); } else { var aggregateOperation = CreateAggregateOperation(renderedPipeline, options); return(ExecuteReadOperation(session, aggregateOperation, cancellationToken)); } }
// methods public override async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options, CancellationToken cancellationToken) { var renderedPipeline = Ensure.IsNotNull(pipeline, nameof(pipeline)).Render(_documentSerializer, _settings.SerializerRegistry); options = options ?? new AggregateOptions(); var last = renderedPipeline.Documents.LastOrDefault(); if (last != null && last.GetElement(0).Name == "$out") { var operation = new AggregateToCollectionOperation( _collectionNamespace, renderedPipeline.Documents, _messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, MaxTime = options.MaxTime }; await ExecuteWriteOperationAsync(operation, cancellationToken).ConfigureAwait(false); var outputCollectionName = last.GetElement(0).Value.AsString; var findOperation = new FindOperation <TResult>( new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName), renderedPipeline.OutputSerializer, _messageEncoderSettings) { BatchSize = options.BatchSize, MaxTime = options.MaxTime }; // we want to delay execution of the find because the user may // not want to iterate the results at all... return(await Task.FromResult <IAsyncCursor <TResult> >(new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperationAsync(findOperation, ReadPreference.Primary, ct))).ConfigureAwait(false)); } else { var aggregateOperation = new AggregateOperation <TResult>( _collectionNamespace, renderedPipeline.Documents, renderedPipeline.OutputSerializer, _messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, MaxTime = options.MaxTime, UseCursor = options.UseCursor }; return(await ExecuteReadOperationAsync(aggregateOperation, cancellationToken).ConfigureAwait(false)); } }
// public methods public override IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { var filteredPipeline = CreateFilteredPipeline(pipeline); return(_wrappedCollection.Aggregate(filteredPipeline, options, cancellationToken)); }
/// <summary> /// Begins a fluent aggregation interface. /// </summary> /// <typeparam name="TDocument">The type of the document.</typeparam> /// <param name="collection">The collection.</param> /// <param name="options">The options.</param> /// <returns> /// A fluent aggregate interface. /// </returns> public static IAggregateFluent <TDocument> Aggregate <TDocument>(this IMongoCollection <TDocument> collection, AggregateOptions options = null) { return(new AggregateFluent <TDocument, TDocument>(collection, Enumerable.Empty <IPipelineStageDefinition>(), options ?? new AggregateOptions())); }
/// <summary> /// Begins a fluent aggregation interface. /// </summary> /// <typeparam name="TDocument">The type of the document.</typeparam> /// <param name="collection">The collection.</param> /// <param name="options">The options.</param> /// <returns> /// A fluent aggregate interface. /// </returns> public static IAggregateFluent <TDocument, TDocument> Aggregate <TDocument>(this IMongoCollection <TDocument> collection, AggregateOptions options = null) { AggregateOptions <TDocument> newOptions; if (options == null) { newOptions = new AggregateOptions <TDocument> { ResultSerializer = collection.DocumentSerializer }; } else { newOptions = new AggregateOptions <TDocument> { AllowDiskUse = options.AllowDiskUse, BatchSize = options.BatchSize, MaxTime = options.MaxTime, ResultSerializer = collection.DocumentSerializer, UseCursor = options.UseCursor }; } return(new AggregateFluent <TDocument, TDocument>(collection, new List <object>(), newOptions)); }
// methods public IAggregateFluent <TDocument, TDocument> Aggregate(AggregateOptions options) { options = options ?? new AggregateOptions(); return(new AggregateFluent <TDocument, TDocument>(this, new List <object>(), options, _serializer)); }
/// <inheritdoc /> public virtual void AggregateToCollection <TResult>(PipelineDefinition <NoPipelineInput, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
/// <summary> /// Begins a fluent aggregation interface. /// </summary> /// <param name="database">The database.</param> /// <param name="session">The session.</param> /// <param name="options">The options.</param> /// <returns> /// A fluent aggregate interface. /// </returns> public static IAggregateFluent <NoPipelineInput> Aggregate(this IMongoDatabase database, IClientSessionHandle session, AggregateOptions options = null) { Ensure.IsNotNull(session, nameof(session)); var emptyPipeline = new EmptyPipelineDefinition <NoPipelineInput>(NoPipelineInputSerializer.Instance); return(new DatabaseAggregateFluent <NoPipelineInput>(session, database, emptyPipeline, options ?? new AggregateOptions())); }
/// <summary> /// Begins a fluent aggregation interface. /// </summary> /// <param name="database">The database.</param> /// <param name="options">The options.</param> /// <returns> /// A fluent aggregate interface. /// </returns> public static IAggregateFluent <NoPipelineInput> Aggregate(this IMongoDatabase database, AggregateOptions options = null) { var emptyPipeline = new EmptyPipelineDefinition <NoPipelineInput>(NoPipelineInputSerializer.Instance); return(new DatabaseAggregateFluent <NoPipelineInput>(null, database, emptyPipeline, options ?? new AggregateOptions())); }
public async Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IEnumerable <object> pipeline, AggregateOptions <TResult> options, CancellationToken cancellationToken) { Ensure.IsNotNull(pipeline, "pipeline"); options = options ?? new AggregateOptions <TResult>(); var pipelineDocuments = pipeline.Select(x => ConvertToBsonDocument(x)).ToList(); var last = pipelineDocuments.LastOrDefault(); if (last != null && last.GetElement(0).Name == "$out") { var operation = new AggregateToCollectionOperation( _collectionNamespace, pipelineDocuments, _messageEncoderSettings) { AllowDiskUse = options.AllowDiskUse, MaxTime = options.MaxTime }; await ExecuteWriteOperation(operation, cancellationToken).ConfigureAwait(false); var outputCollectionName = last.GetElement(0).Value.AsString; var resultSerializer = ResolveResultSerializer(options.ResultSerializer); var findOperation = new FindOperation <TResult>( new CollectionNamespace(_collectionNamespace.DatabaseNamespace, outputCollectionName), resultSerializer, _messageEncoderSettings) { BatchSize = options.BatchSize, MaxTime = options.MaxTime }; // we want to delay execution of the find because the user may // not want to iterate the results at all... return(await Task.FromResult <IAsyncCursor <TResult> >(new DeferredAsyncCursor <TResult>(ct => ExecuteReadOperation(findOperation, ct))).ConfigureAwait(false)); } else { var operation = CreateAggregateOperation <TResult>(options, pipelineDocuments); return(await ExecuteReadOperation(operation, cancellationToken).ConfigureAwait(false)); } }