public void NewSessionAndUpdatePhase()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var sessionOfExperts = new SessionOfExperts("BaseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(sessionOfExperts);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var session = LinqProvider.Query <SessionOfExperts>().Single();
session.NextPhaseOrFinish();
GetRepository <SessionOfExperts>().AddOrUpdate(session);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var session = LinqProvider.Query <SessionOfExperts>().Single();
session.CurrentPhase.Should().Be(SessionPhase.SpecifyingAssociationsTypes);
session.StartTime.Should().BeNow();
session.BaseNotion.Should().Be("BaseNotion");
}
}
public void Aggregate_Group_with_expressions_should_work(
[Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
{
var collection = GetCollection <BsonDocument>(linqProvider);
var aggregate = collection.Aggregate()
.Group(x => 1, x => new { Count = x.Count() });
var stages = Linq3TestHelpers.Translate(collection, aggregate);
var expectedStages = linqProvider switch
{
LinqProvider.V2 =>
new[]
{
"{ $group : { _id : 1, Count : { $sum : 1 } } }"
},
LinqProvider.V3 =>
new[]
{
"{ $group : { _id : 1, __agg0 : { $sum : 1 } } }",
"{ $project : { Count : '$__agg0', _id : 0 } }"
},
_ => throw new ArgumentException()
};
Linq3TestHelpers.AssertStages(stages, expectedStages);
}
private BsonValue Render <TDocument>(UpdateDefinition <TDocument> update, LinqProvider linqProvider)
{
var documentSerializer = BsonSerializer.LookupSerializer <TDocument>();
var serializerRegistry = BsonSerializer.SerializerRegistry;
return(update.Render(documentSerializer, serializerRegistry, linqProvider));
}
private IMongoCollection <TDocument> GetCollection <TDocument>(LinqProvider linqProvider)
{
var client = linqProvider == LinqProvider.V2 ? DriverTestConfiguration.Client : DriverTestConfiguration.Linq3Client;
var database = client.GetDatabase("test");
return(database.GetCollection <TDocument>("test"));
}
public override RenderedPipelineStageDefinition <IGrouping <TKey, TInput> > Render(
IBsonSerializer <TInput> inputSerializer,
IBsonSerializerRegistry serializerRegistry,
LinqProvider linqProvider)
{
if (linqProvider != LinqProvider.V3)
{
throw new InvalidOperationException("GroupExpressionStageDefinitions can only be used with LINQ3.");
}
var expression = CreateExpression(inputSerializer);
expression = PartialEvaluator.EvaluatePartially(expression);
var context = TranslationContext.Create(expression, inputSerializer);
var unoptimizedPipeline = ExpressionToPipelineTranslator.Translate(context, expression);
var pipeline = AstPipelineOptimizer.Optimize(unoptimizedPipeline);
var groupStageDocument = pipeline.Stages[0].Render().AsBsonDocument;
var renderedGroupStage = new RenderedPipelineStageDefinition <IGrouping <TKey, TInput> >("$group", groupStageDocument, new DummyIGroupingSerializer());
var projectStageDocument = pipeline.Stages[1].Render().AsBsonDocument;
_renderedProjectStage = new RenderedPipelineStageDefinition <TOutput>("$project", projectStageDocument, (IBsonSerializer <TOutput>)pipeline.OutputSerializer);
return(renderedGroupStage);
}
public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult, TDocument>(
IMongoCollection <TDocument> collection,
PipelineDefinition <ChangeStreamDocument <TDocument>, TResult> pipeline,
IBsonSerializer <TDocument> documentSerializer,
LinqProvider linqProvider,
ChangeStreamOptions options,
ReadConcern readConcern,
MessageEncoderSettings messageEncoderSettings,
bool retryRequested)
{
var renderedPipeline = RenderPipeline(pipeline, documentSerializer, linqProvider);
var operation = new ChangeStreamOperation <TResult>(
collection.CollectionNamespace,
renderedPipeline.Documents,
renderedPipeline.OutputSerializer,
messageEncoderSettings)
{
RetryRequested = retryRequested
};
SetOperationOptions(operation, options, readConcern);
return(operation);
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <param name="linqProvider">The LINQ provider.</param>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public string ToString(LinqProvider linqProvider)
{
var serializerRegistry = BsonSerializer.SerializerRegistry;
var inputSerializer = serializerRegistry.GetSerializer <TInput>();
return(ToString(inputSerializer, serializerRegistry, linqProvider));
}
public void TestAddSession()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var notionType = new NotionType("type");
GetRepository <NotionType>().AddOrUpdate(notionType);
var node = new Node("notion", notionType);
GetRepository <Node>().AddOrUpdate(node);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var session = new SessionOfExperts("baseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(session);
var node = LinqProvider.Query <Node>().Single();
node.AddSessionOfExperts(session);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var node = LinqProvider.Query <Node>().Single();
node.SessionsOfExperts.Count.Should().Be(1);
}
}
public void UpdateLastCompletedPhase()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var sessionOfExperts = new SessionOfExperts("baseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(sessionOfExperts);
var expert = new Expert("expertName", sessionOfExperts);
GetRepository <Expert>().AddOrUpdate(expert);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
expert.LastCompletedPhase = SessionPhase.SpecifyingAssociationsTypes;
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
expert.LastCompletedPhase.Should().Be(SessionPhase.SpecifyingAssociationsTypes);
}
}
public override BsonDocument Render(
IBsonSerializer <T> documentSerializer,
IBsonSerializerRegistry serializerRegistry,
LinqProvider provider)
{
return(Render(documentSerializer, serializerRegistry));
}
public void ReplaceAssociation_NotEmptyCollection()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var sessionOfExperts = new SessionOfExperts("baseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(sessionOfExperts);
var expert = new Expert("expertName", sessionOfExperts);
expert.ReplaceAllAssociations(new[] { "notion1", "notion2" });
GetRepository <Expert>().AddOrUpdate(expert);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
expert.ReplaceAllAssociations(new[] { "notion3", "notion4" });
GetRepository <Expert>().AddOrUpdate(expert);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
expert.Associations.Should().BeEquivalentTo(
new[]
{
new { Expert = expert, Notion = "notion3" },
new { Expert = expert, Notion = "notion4" }
},
opt => opt.ExcludingMissingMembers());
}
}
public override RenderedPipelineStageDefinition <TOutput> Render(
IBsonSerializer <TInput> inputSerializer,
IBsonSerializerRegistry serializerRegistry,
LinqProvider linqProvider)
{
return(renderer(inputSerializer));
}
// private static methods
private static RenderedPipelineDefinition <TResult> RenderPipeline <TResult, TDocument>(
PipelineDefinition <ChangeStreamDocument <TDocument>, TResult> pipeline,
IBsonSerializer <TDocument> documentSerializer,
LinqProvider linqProvider)
{
var changeStreamDocumentSerializer = new ChangeStreamDocumentSerializer <TDocument>(documentSerializer);
var serializerRegistry = BsonSerializer.SerializerRegistry;
return(pipeline.Render(changeStreamDocumentSerializer, serializerRegistry, linqProvider));
}
public void PipelineStageDefinitionBuilder_Group_with_projection_to_TOutput_should_work(
[Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
{
var stageDefinition = PipelineStageDefinitionBuilder.Group <BsonDocument, BsonDocument>("{ _id : 1, Count : { $sum : 1 } }");
var stage = Linq3TestHelpers.Render(stageDefinition, BsonDocumentSerializer.Instance, linqProvider);
var expectedStages = new[]
{
"{ $group : { _id : 1, Count : { $sum : 1 } } }"
};
Linq3TestHelpers.AssertStages(new[] { stage }, expectedStages);
}
/// <summary>
/// Initializes a new instance of the MongoClient class.
/// </summary>
/// <param name="settings">The settings.</param>
public MongoClient(MongoClientSettings settings)
{
_settings = Ensure.IsNotNull(settings, nameof(settings)).FrozenCopy();
_linqProvider = _settings.LinqProvider;
_cluster = ClusterRegistry.Instance.GetOrCreateCluster(_settings.ToClusterKey());
_operationExecutor = new OperationExecutor(this);
if (settings.AutoEncryptionOptions != null)
{
_libMongoCryptController = AutoEncryptionLibMongoCryptController.Create(
this,
_cluster.CryptClient,
settings.AutoEncryptionOptions);
}
}
public void PipelineDefinitionBuilder_Group_with_projection_to_implied_BsonDocument_should_work(
[Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
{
var emptyPipeline = (PipelineDefinition <BsonDocument, BsonDocument>) new EmptyPipelineDefinition <BsonDocument>();
var pipeline = emptyPipeline.Group("{ _id : 1, Count : { $sum : 1 } }");
var stages = Linq3TestHelpers.Render(pipeline, BsonDocumentSerializer.Instance, linqProvider);
var expectedStages = new[]
{
"{ $group : { _id : 1, Count : { $sum : 1 } } }"
};
Linq3TestHelpers.AssertStages(stages, expectedStages);
}
public void Aggregate_Group_with_projection_to_TNewResult_should_work(
[Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
{
var collection = GetCollection <BsonDocument>(linqProvider);
var aggregate = collection.Aggregate()
.Group <Result>("{ _id : 1, Count : { $sum : 1 } }");
var stages = Linq3TestHelpers.Translate(collection, aggregate);
var expectedStages = new[]
{
"{ $group : { _id : 1, Count : { $sum : 1 } } }"
};
Linq3TestHelpers.AssertStages(stages, expectedStages);
}
// constructors
public MongoDatabaseImpl(IMongoClient client, DatabaseNamespace databaseNamespace, MongoDatabaseSettings settings, ICluster cluster, IOperationExecutor operationExecutor)
{
_client = Ensure.IsNotNull(client, nameof(client));
_databaseNamespace = Ensure.IsNotNull(databaseNamespace, nameof(databaseNamespace));
_settings = Ensure.IsNotNull(settings, nameof(settings)).Freeze();
_cluster = Ensure.IsNotNull(cluster, nameof(cluster));
_operationExecutor = Ensure.IsNotNull(operationExecutor, nameof(operationExecutor));
_linqProvider = _client.Settings.LinqProvider;
_messageEncoderSettings = new MessageEncoderSettings
{
{ MessageEncoderSettingsName.ReadEncoding, _settings.ReadEncoding ?? Utf8Encodings.Strict },
{ MessageEncoderSettingsName.WriteEncoding, _settings.WriteEncoding ?? Utf8Encodings.Strict }
};
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
_messageEncoderSettings.Add(MessageEncoderSettingsName.GuidRepresentation, _settings.GuidRepresentation);
}
#pragma warning restore 618
}
public static ChangeStreamOperation <TResult> CreateChangeStreamOperation <TResult>(
PipelineDefinition <ChangeStreamDocument <BsonDocument>, TResult> pipeline,
LinqProvider linqProvider,
ChangeStreamOptions options,
ReadConcern readConcern,
MessageEncoderSettings messageEncoderSettings,
bool retryRequested)
{
var renderedPipeline = RenderPipeline(pipeline, BsonDocumentSerializer.Instance, linqProvider);
var operation = new ChangeStreamOperation <TResult>(
renderedPipeline.Documents,
renderedPipeline.OutputSerializer,
messageEncoderSettings)
{
RetryRequested = retryRequested
};
SetOperationOptions(operation, options, readConcern);
return(operation);
}
public void UpdateAssociationTypes()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var sessionOfExperts = new SessionOfExperts("baseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(sessionOfExperts);
var expert = new Expert("expertName", sessionOfExperts);
expert.ReplaceAllAssociations(new[] { "notion1", "notion2" });
GetRepository <Expert>().AddOrUpdate(expert);
unitOfWork.Commit();
}
Guid associationIdForUpdate;
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
associationIdForUpdate = LinqProvider.Query <Association>().First().Id;
var type = new NotionType("NotionType");
GetRepository <NotionType>().AddOrUpdate(type);
expert.SetTypeForAssociation(associationIdForUpdate, type, "offer");
GetRepository <Expert>().AddOrUpdate(expert);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var expert = LinqProvider.Query <Expert>().Single();
var type = LinqProvider.Query <NotionType>().Single();
expert.Associations.Single(x => x.Id == associationIdForUpdate).Should().BeEquivalentTo(
new { Expert = expert, Type = type, OfferType = "offer" },
opt => opt.ExcludingMissingMembers());
}
}
public void TestAddSession()
{
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var notionType = new NotionType("type");
GetRepository <NotionType>().AddOrUpdate(notionType);
var node1 = new Node("notion1", notionType);
GetRepository <Node>().AddOrUpdate(node1);
var node2 = new Node("notion2", notionType);
GetRepository <Node>().AddOrUpdate(node2);
var relationType = new RelationType("type");
GetRepository <RelationType>().AddOrUpdate(relationType);
var verge = new Verge(node1, node2, relationType, 20);
GetRepository <Verge>().AddOrUpdate(verge);
unitOfWork.Commit();
}
using (var unitOfWork = UnitOfWorkFactory.Create()) {
var session = new SessionOfExperts("baseNotion");
GetRepository <SessionOfExperts>().AddOrUpdate(session);
var verge = LinqProvider.Query <Verge>().Single();
verge.UpdateWeightFromSession(20, session);
unitOfWork.Commit();
}
using (UnitOfWorkFactory.Create()) {
var verge = LinqProvider.Query <Verge>().Single();
verge.SessionWeightSlices.Count.Should().Be(1);
}
}
/// <inheritdoc />
public override RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
return(new RenderedPipelineStageDefinition <TOutput>(
OperatorName,
BsonDocument.Parse(_json),
_outputSerializer ?? (inputSerializer as IBsonSerializer <TOutput>) ?? serializerRegistry.GetSerializer <TOutput>()));
}
/// <inheritdoc />
IRenderedPipelineStageDefinition IPipelineStageDefinition.Render(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
return(Render((IBsonSerializer <TInput>)inputSerializer, serializerRegistry, linqProvider));
}
string IPipelineStageDefinition.ToString(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
return(ToString((IBsonSerializer <TInput>)inputSerializer, serializerRegistry, linqProvider));
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <param name="inputSerializer">The input serializer.</param>
/// <param name="serializerRegistry">The serializer registry.</param>
/// <param name="linqProvider">The LINQ provider.</param>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public string ToString(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
var renderedStage = Render(inputSerializer, serializerRegistry, linqProvider);
return(renderedStage.Document.ToJson());
}
/// <summary>
/// Renders the specified document serializer.
/// </summary>
/// <param name="inputSerializer">The input serializer.</param>
/// <param name="serializerRegistry">The serializer registry.</param>
/// <param name="linqProvider">The LINQ provider.</param>
/// <returns>A <see cref="RenderedPipelineStageDefinition{TOutput}" /></returns>
public abstract RenderedPipelineStageDefinition <TOutput> Render(IBsonSerializer <TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider);
// public methods /// <summary> /// Renders the array filter to a <see cref="BsonDocument" />. /// </summary> /// <param name="itemSerializer">The item serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <param name="linqProvider">The LINQ provider.</param> /// <returns> /// A <see cref="BsonDocument" />. /// </returns> public abstract BsonDocument Render(IBsonSerializer itemSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider);
/// <inheritdoc />
public override BsonDocument Render(IBsonSerializer <TItem> itemSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
return(_document);
}
/// <summary> /// Renders the aggregation expression. /// </summary> /// <param name="sourceSerializer">The source serializer.</param> /// <param name="serializerRegistry">The serializer registry.</param> /// <param name="linqProvider">The LINQ provider.</param> /// <returns>The rendered aggregation expression.</returns> public abstract BsonValue Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider);
// public methods
/// <inheritdoc/>
public override BsonValue Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
var contextData = _contextData?.With("SerializerRegistry", serializerRegistry);
return(linqProvider.GetAdapter().TranslateExpressionToAggregateExpression(_expression, sourceSerializer, serializerRegistry, _translationOptions, contextData));
}
