public abstract void CreateView <TDocument, TResult>(String viewName, String viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken));
/// <inheritdoc/>
public Task <IAsyncCursor <TResult> > WatchAsync <TResult>(IClientSessionHandle session, PipelineDefinition <ChangeStreamDocument <T>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
private RenderedPipelineDefinition <TOutput> RenderPipeline <TInput, TOutput>(PipelineDefinition <TInput, TOutput> pipeline)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var inputSerializer = serializerRegistry.GetSerializer <TInput>();
return(pipeline.Render(inputSerializer, serializerRegistry));
}
/// <inheritdoc/>
public Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IClientSessionHandle session, PipelineDefinition <T, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default)
{
return(_actualCollection.AggregateAsync(session, pipeline, options, cancellationToken));
}
/// <inheritdoc/>
public Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(IClientSessionHandle session, PipelineDefinition <T, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
public static TResult Iterate <TSource, TResult>(IMongoCollection <TSource> collection, PipelineDefinition <TSource, BsonDocument> pipeline, Func <BsonDocument, TResult, TResult> callback)
{
var docCursor = collection.Aggregate(pipeline);
TResult value = default(TResult);
while (docCursor.MoveNext())
{
var doc = docCursor.Current;
foreach (var item in doc)
{
value = callback.Invoke(item, value);
}
}
return(value);
}
/// <inheritdoc/>
public Task <IAsyncCursor <TResult> > WatchAsync <TResult>(IClientSessionHandle session, PipelineDefinition <ChangeStreamDocument <T>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
{
return(_actualCollection.WatchAsync(session, pipeline, options, cancellationToken));
}
public void Aggregate(PipelineDefinition <T, BsonDocument> pipeline) => Collection.AggregateToCollection(pipeline);
public Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.FromResult(Aggregate(pipeline, options, cancellationToken)));
}
public void CreateView <TDocument, TResult>(string viewName, string viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
_database.CreateView(viewName, viewOn, pipeline, options, cancellationToken);
}
public Task CreateViewAsync <TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(_database.CreateViewAsync(session, viewName, viewOn, pipeline, options, cancellationToken));
}
private void ParseUpdateModel(
BsonDocument model,
out FilterDefinition <BsonDocument> filter,
out UpdateDefinition <BsonDocument> update,
out List <ArrayFilterDefinition> arrayFilters,
out BsonValue hint,
out bool isUpsert)
{
arrayFilters = null;
filter = null;
update = null;
hint = null;
isUpsert = false;
foreach (BsonElement argument in model.Elements)
{
switch (argument.Name)
{
case "arrayFilters":
arrayFilters = argument
.Value
.AsBsonArray
.Cast <BsonDocument>()
.Select(x => new BsonDocumentArrayFilterDefinition <BsonValue>(x))
.ToList <ArrayFilterDefinition>();
break;
case "filter":
filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
case "hint":
hint = argument.Value;
break;
case "update":
switch (argument.Value)
{
case BsonDocument:
update = argument.Value.AsBsonDocument;
break;
case BsonArray:
update = PipelineDefinition <BsonDocument, BsonDocument> .Create(argument.Value.AsBsonArray.Cast <BsonDocument>());
break;
default:
throw new FormatException($"Invalid BulkWrite Update model update argument: '{argument.Value}'.");
}
break;
case "upsert":
isUpsert = argument.Value.ToBoolean();
break;
default:
throw new FormatException($"Invalid BulkWrite Update model argument name: '{argument.Name}'.");
}
}
}
// private methods
private RenderedPipelineDefinition <ChangeStreamDocument <BsonDocument> > RenderPipeline(PipelineDefinition <ChangeStreamDocument <BsonDocument>, ChangeStreamDocument <BsonDocument> > pipeline)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var inputSerializer = new ChangeStreamDocumentSerializer <BsonDocument>(BsonDocumentSerializer.Instance);
return(pipeline.Render(inputSerializer, serializerRegistry));
}
public Task CreateViewAsync <TDocument, TResult>(String viewName, String viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
CreateView(viewName, viewOn, pipeline, options, cancellationToken);
return(Task.CompletedTask);
}
// private methods
private IList <BsonDocument> RenderStages <TInput, TOutput>(PipelineDefinition <TInput, TOutput> pipeline, IBsonSerializer <TInput> inputSerializer)
{
var renderedPipeline = pipeline.Render(inputSerializer, BsonSerializer.SerializerRegistry);
return(renderedPipeline.Documents);
}
public abstract IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <TDocument, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
public IAsyncCursor <TResult> AsyncCursor <TDocument, TKey, TResult>(
PipelineDefinition <TDocument, TResult> pipelineDefinition) where TDocument : AggregateRootWithId <TKey>
{
return(_dbContext.GetCollection <TDocument>().Aggregate(pipelineDefinition));
}
/// <inheritdoc/>
public Task CreateViewAsync <TDocument, TResult>(IClientSessionHandle session, string viewName, string viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default)
{
throw new System.NotImplementedException();
}
/// <inheritdoc/>
public IAsyncCursor <TResult> Watch <TResult>(PipelineDefinition <ChangeStreamDocument <T>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default)
{
return(_actualCollection.Watch(pipeline, options, cancellationToken));
}
/// <inheritdoc/>
public void CreateView <TDocument, TResult>(string viewName, string viewOn, PipelineDefinition <TDocument, TResult> pipeline, CreateViewOptions <TDocument> options = null, CancellationToken cancellationToken = default)
{
throw new System.NotImplementedException();
}
/// <inheritdoc/>
public IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <T, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default)
{
return(_actualCollection.Aggregate(pipeline, options, cancellationToken));
}
public async Task CountMovies()
{
// This stage finds all movies that have a specific director
var matchStage = new BsonDocument("$match",
new BsonDocument("directors", "Rob Reiner"));
// This stage sorts the results by the number of reviews,
// in descending order
var sortStage = new BsonDocument("$sort",
new BsonDocument("tomatoes.viewer.numReviews", -1));
// This stage generates the projection we want
var projectionStage = new BsonDocument("$project",
new BsonDocument
{
{ "_id", 0 },
{ "Movie Title", "$title" },
{ "Year", "$year" },
{ "Average User Rating", "$tomatoes.viewer.rating" }
});
/* We now put the stages together in a pipeline. Note that a
* pipeline definition requires us to specify the input and output
* types. In this case, the input is of type Movie, but because
* we are using a Projection with custom fields, our output is
* a generic BsonDocument object. To be really cool, we could
* create a mapping class for the output type, which is what we've
* done for you in the MFlix application.
*/
var pipeline = PipelineDefinition <Movie, BsonDocument>
.Create(new BsonDocument[] {
matchStage,
sortStage,
projectionStage
});
var result = await _moviesCollection.Aggregate(pipeline).ToListAsync();
/* Note: we're making a synchronous Aggregate() call.
* If you want a challenge, change the line above to make an
* asynchronous call (hint: you'll need to make 2 changes),
* and then confirm the unit test still passes.
*/
Assert.AreEqual(14, result.Count);
var firstMovie = result[0];
Assert.AreEqual("The Princess Bride", firstMovie.GetValue("Movie Title").AsString);
Assert.AreEqual(1987, firstMovie.GetValue("Year").AsInt32);
Assert.AreEqual(4.0, firstMovie.GetValue("Average User Rating").AsDouble);
/* We specifically excluded the "Id" field in the projection stage
* that we built in the code above, so let's make sure that field
* wasn't included in the resulting BsonDocument. We expect the call
* to GetValue() to throw a KeyNotFoundException exception if the
* field doesn't exist.
*/
Assert.Throws <KeyNotFoundException>(() => firstMovie.GetValue("Id"));
}
/// <inheritdoc/>
public IAsyncCursor <TResult> Aggregate <TResult>(PipelineDefinition <T, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
private List <BsonDocument> RenderPipeline <TInput, TOutput>(PipelineDefinition <TInput, TOutput> pipeline)
{
var serializer = BsonSerializer.SerializerRegistry.GetSerializer <TInput>();
return(pipeline.Render(serializer, BsonSerializer.SerializerRegistry).Documents.ToList());
}
/// <inheritdoc/>
public IAsyncCursor <TResult> Watch <TResult>(PipelineDefinition <ChangeStreamDocument <T>, TResult> pipeline, ChangeStreamOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
public Task <IAsyncCursor <TResult> > AggregateAsync <TResult>(PipelineDefinition <T, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(_Repository.AggregateAsync(pipeline, options, cancellationToken));
}
public IEnumerator <ChangeStreamDocument <ProfileEntity> > SubscribeToChangesMany(
PipelineDefinition <ChangeStreamDocument <ProfileEntity>, ChangeStreamDocument <ProfileEntity> > pipeline
)
{
return(_mongoRepository.SubscribeToChangesStreamMany(pipeline) !);
}
public List <BsonDocument> Aggregate(string mongodbConnStr, string mongodbDatabase, string coll, PipelineDefinition <BsonDocument, BsonDocument> pipeline)
{
var client = new MongoClient(mongodbConnStr);
var database = client.GetDatabase(mongodbDatabase);
var collection = database.GetCollection <BsonDocument>(coll);
var query = collection.Aggregate(pipeline).ToList();
client = null;
return(query);
}
public void TestExpressionQueries(IMongoCollection <MongoItem> col, IMongoQueryable <MongoItem> query)
{
#region Various LINQ-Expressions to combine and test
Expression <Func <MongoItem, bool> > cityExpressionVienna = (d => d.City == "Vienna");
Expression <Func <MongoItem, bool> > cityExpressionGraz = (d => d.City == "Graz");
Expression <Func <MongoItem, bool> > firstNameExpression = (d => d.DemoUser.FirstName == "Michaela");
Expression <Func <MongoItem, bool> > firstNameExpression2 = (d => (d.DemoUser.FirstName == "Michaela" || d.City == "Graz"));
Expression <Func <MongoItem, bool> > modeExpression = (d => (d.Mode == "ModeA" || d.Mode == "ModeB" || d.Mode == "ModeC"));
Expression <Func <MongoItem, bool> > modeExpression2 = (d => (d.Mode != "ModeA" && d.Mode != "ModeB" && d.Mode != "ModeC"));
Expression <Func <MongoItem, bool> > modeExpression3 = (d => (d.Mode == "ModeA"));
DateTimeOffset sFrom = DateTimeOffset.ParseExact("2017:04:02 18:00:00", "yyyy:MM:dd HH:mm:ss", null).ToUniversalTime();
DateTimeOffset sTo = DateTimeOffset.ParseExact("2017:04:03 15:59:00", "yyyy:MM:dd HH:mm:ss", null).ToUniversalTime();
//Expression<Func<MongoItem, bool>> isWithinDateRange = (d => (d.CheckPoint.CompareTo(sFrom) >= 0 && d.CheckPoint.CompareTo(sTo) <= 0));
Expression <Func <MongoItem, bool> > isWithinDateRange = (d => (d.CheckPointUTC.CompareTo(sFrom.ToString("u")) >= 0 && d.CheckPointUTC.CompareTo(sTo.ToString("u")) <= 0));
Expression <Func <MongoItem, bool> > containsTagFemale = (d => d.TagList.Contains <string>("female"));
Expression <Func <MongoItem, bool> > containsUserID = (d => d.UserList.Contains <string>("martinau"));
//Expression<Func<MongoItem, DateTimeOffset>> orderByDate = t => t.CheckPoint;
Expression <Func <MongoItem, string> > orderByDate = t => t.CheckPointUTC;
#endregion
#region Build a LINQ-Query, turn it to JSON, create aggregate Pipeline with BSON from JSON
PipelineDefinition <MongoItem, MongoItem> aggregatePipeline = null;
// Build a more complex LINQ Query
var query0 = query.Where(cityExpressionVienna).OrderBy("CheckPointUTC ASC").Skip(1).Take(2);
// Use the overloaded toString()-method to retrieve the aggregate-query ==> "aggregate([{match-Expression},...])
string mongoAggregateQueryString = query0.ToString();
Regex aggregateParameters = new Regex(@"(aggregate\()(.*)(\)$)");
mongoAggregateQueryString = aggregateParameters.Match(mongoAggregateQueryString).Groups[2].Value;
List <BsonDocument> docs = new List <BsonDocument>();
var aggElements = BsonSerializer.Deserialize <BsonArray>(mongoAggregateQueryString);
foreach (var el in aggElements)
{
docs.Add(el.AsBsonDocument);
}
aggregatePipeline = docs.ToArray <BsonDocument>();
//Build a Pipeline out of multiple single Bson documents
//BsonDocument matchBsonDoc = BsonDocument.Parse("{ \"$match\" : { \"City\" : \"Vienna\" } }");
//aggregatePipeline = new BsonDocument[]
//{
// matchBsonDoc,
// new BsonDocument { { "$sort", new BsonDocument("CheckPointUTC", 1) } }
//};
int assertCounter = 0;
var aggregateResults = col.Aggregate(aggregatePipeline);
foreach (var item in aggregateResults.ToList <MongoItem>())
{
Console.WriteLine($"{item.DemoUser.FirstName} {item.DemoUser.LastName}");
if (assertCounter == 0)
{
Debug.Assert(item.DemoUser.FirstName == "Nina");
}
if (assertCounter == 0)
{
Debug.Assert(item.DemoUser.LastName == "Huber");
}
if (assertCounter == 1)
{
Debug.Assert(item.DemoUser.FirstName == "Michaela");
}
if (assertCounter == 1)
{
Debug.Assert(item.DemoUser.LastName == "Bauer");
}
assertCounter++;
}
Debug.Assert(assertCounter == 2);
#endregion
var query1 = query.Where(cityExpressionVienna).OrderBy(orderByDate);
var query2 = query.Where(cityExpressionVienna).OrderByDescending(orderByDate);
var query3 = query.Where(cityExpressionVienna.AndAlso(modeExpression3));
var query3Same = query.Where((d => d.City == "Vienna" && d.Mode == "ModeA"));
var query4 = query.Where(cityExpressionVienna.AndAlso(containsTagFemale)).OrderBy(orderByDate);
var query5 = query.Where(cityExpressionGraz.AndAlso(containsTagFemale).AndAlso(containsUserID)).OrderBy(orderByDate);
var query6 = query.Where(cityExpressionVienna.AndAlso(isWithinDateRange)).OrderBy(orderByDate);
List <MongoItem> queryResult = null;
queryResult = query1.ToList <MongoItem>();
queryResult.Assert(new string[] { "Andreas Pollak", "Nina Huber", "Michaela Bauer" });
queryResult = query2.ToList <MongoItem>();
queryResult.Assert(new string[] { "Michaela Bauer", "Nina Huber", "Andreas Pollak" });
queryResult = query3.ToList <MongoItem>();
queryResult.Assert(new string[] { "Andreas Pollak", "Nina Huber" });
queryResult = query3Same.ToList <MongoItem>();
queryResult.Assert(new string[] { "Andreas Pollak", "Nina Huber" });
queryResult = query6.ToList <MongoItem>();
queryResult.Assert(new string[] { "Andreas Pollak", "Nina Huber" });
// Folgende Queries können nicht über die CosmosDB ausgeführt werden!!
// {aggregate([{ "$match" : { "TagList" : "female" } }])}
var testQuery = query.Where(containsTagFemale);
queryResult = testQuery.ToList <MongoItem>();
Debug.Assert(queryResult.Count() == 5);
queryResult = query4.ToList <MongoItem>();
queryResult.Assert(new string[] { "Nina Huber", "Michaela Bauer" });
queryResult = query5.ToList <MongoItem>();
queryResult.Assert(new string[] { "Martina Uhlig" });
}
public Task AggregateToCollectionAsync <TResult>(IClientSessionHandle session, PipelineDefinition <SitePage, TResult> pipeline, AggregateOptions options = null, CancellationToken cancellationToken = default)
{
throw new NotImplementedException();
}
