public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedField = _field.Render(sourceSerializer, serializerRegistry);
IBsonSerializer <TItem> itemSerializer;
if (renderedField.FieldSerializer != null)
{
var arraySerializer = renderedField.FieldSerializer as IBsonArraySerializer;
BsonSerializationInfo itemSerializationInfo;
if (arraySerializer == null || !arraySerializer.TryGetItemSerializationInfo(out itemSerializationInfo))
{
var message = string.Format("The serializer for field '{0}' must implement IBsonArraySerializer and provide item serialization info.", renderedField.FieldName);
throw new InvalidOperationException(message);
}
itemSerializer = (IBsonSerializer <TItem>)itemSerializationInfo.Serializer;
}
else
{
itemSerializer = serializerRegistry.GetSerializer <TItem>();
}
var renderedFilter = _filter.Render(itemSerializer, serializerRegistry);
return(new BsonDocument(renderedField.FieldName, new BsonDocument("$elemMatch", renderedFilter)));
}
public override IAggregateFluent <TNewResult> GraphLookup <TNewResult, TFrom, TConnect, TConnectFrom, TStartWith, TAs, TAsEnumerable>(
IMongoCollection <TFrom> from,
FieldDefinition <TFrom, TConnectFrom> connectFromField,
FieldDefinition <TFrom, TConnect> connectToField,
AggregateExpressionDefinition <TResult, TStartWith> startWith,
FieldDefinition <TNewResult, TAsEnumerable> @as,
FieldDefinition <TAs, int> depthField,
AggregateGraphLookupOptions <TNewResult, TFrom, TConnect, TConnectFrom, TStartWith, TAs, TAsEnumerable> options = null)
{
Ensure.IsNotNull(from, nameof(from));
Ensure.IsNotNull(connectFromField, nameof(connectFromField));
Ensure.IsNotNull(connectToField, nameof(connectToField));
Ensure.IsNotNull(startWith, nameof(startWith));
Ensure.IsNotNull(@as, nameof(@as));
Ensure.That(from.Database.DatabaseNamespace.Equals(_collection.Database.DatabaseNamespace), "From collection must be from the same database.", nameof(from));
Ensure.That(IsTConnectOrEnumerableTConnect <TConnectFrom, TConnect>(), "TConnectFrom must be either TConnect or a type that implements IEnumerable<TConnect>.", nameof(TConnectFrom));
Ensure.That(IsTConnectOrEnumerableTConnect <TStartWith, TConnect>(), "TStartWith must be either TConnect or a type that implements IEnumerable<TConnect>.", nameof(TStartWith));
const string operatorName = "$graphLookup";
var stage = new DelegatedPipelineStageDefinition <TResult, TNewResult>(
operatorName,
(s, sr) =>
{
var resultSerializer = s;
var newResultSerializer = options?.NewResultSerializer ?? sr.GetSerializer <TNewResult>();
var fromSerializer = options?.FromSerializer ?? sr.GetSerializer <TFrom>();
var asSerializer = options?.AsSerializer ?? sr.GetSerializer <TAs>();
var renderedConnectToField = connectToField.Render(fromSerializer, sr);
var renderedStartWith = startWith.Render(resultSerializer, sr);
var renderedConnectFromField = connectFromField.Render(fromSerializer, sr);
var renderedAs = @as.Render(newResultSerializer, sr);
var renderedDepthField = depthField?.Render(asSerializer, sr);
var renderedRestrictSearchWithMatch = options?.RestrictSearchWithMatch?.Render(fromSerializer, sr);
var document = new BsonDocument
{
{ operatorName, new BsonDocument
{
{ "from", from.CollectionNamespace.CollectionName },
{ "connectFromField", renderedConnectFromField.FieldName },
{ "connectToField", renderedConnectToField.FieldName },
{ "startWith", renderedStartWith },
{ "as", renderedAs.FieldName },
{ "depthField", () => renderedDepthField.FieldName, renderedDepthField != null },
{ "maxDepth", () => options.MaxDepth.Value, options != null && options.MaxDepth.HasValue },
{ "restrictSearchWithMatch", renderedRestrictSearchWithMatch, renderedRestrictSearchWithMatch != null }
} }
};
return(new RenderedPipelineStageDefinition <TNewResult>(operatorName, document, newResultSerializer));
});
return(AppendStage <TNewResult>(stage));
}
public override IAggregateFluent <TNewResult> Unwind <TNewResult>(FieldDefinition <TResult> field, IBsonSerializer <TNewResult> newResultSerializer)
{
const string operatorName = "$unwind";
var stage = new DelegatedPipelineStageDefinition <TResult, TNewResult>(
operatorName,
(s, sr) => new RenderedPipelineStageDefinition <TNewResult>(
operatorName, new BsonDocument(
operatorName,
"$" + field.Render(s, sr).FieldName),
newResultSerializer ?? (s as IBsonSerializer <TNewResult>) ?? sr.GetSerializer <TNewResult>()));
return(AppendStage <TNewResult>(stage));
}
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedField = _field.Render(documentSerializer, serializerRegistry);
var document = new BsonDocument(renderedField.FieldName, "geoHaystack");
if (_additionalFieldName != null)
{
var additionalRenderedField = _additionalFieldName.Render(documentSerializer, serializerRegistry);
document.Add(additionalRenderedField.FieldName, 1);
}
return(document);
}
private DistinctOperation <TField> CreateDistinctOperation <TField>(FieldDefinition <TDocument, TField> field, FilterDefinition <TDocument> filter, DistinctOptions options)
{
var renderedField = field.Render(_documentSerializer, _settings.SerializerRegistry);
return(new DistinctOperation <TField>(
_collectionNamespace,
renderedField.FieldSerializer,
renderedField.FieldName,
_messageEncoderSettings)
{
Filter = filter.Render(_documentSerializer, _settings.SerializerRegistry),
MaxTime = options.MaxTime,
ReadConcern = _settings.ReadConcern
});
}
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
string fieldName;
if (_field == null)
{
fieldName = "$**";
}
else
{
var renderedField = _field.Render(documentSerializer, serializerRegistry);
fieldName = renderedField.FieldName;
fieldName += ".$**";
}
return(new BsonDocument(fieldName, 1));
}
public override Task <IAsyncCursor <TField> > DistinctAsync <TField>(FieldDefinition <TDocument, TField> field, FilterDefinition <TDocument> filter, DistinctOptions options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(field, "field");
Ensure.IsNotNull(filter, "filter");
options = options ?? new DistinctOptions();
var renderedField = field.Render(_documentSerializer, _settings.SerializerRegistry);
var operation = new DistinctOperation <TField>(
_collectionNamespace,
renderedField.FieldSerializer,
renderedField.FieldName,
_messageEncoderSettings)
{
Filter = filter.Render(_documentSerializer, _settings.SerializerRegistry),
MaxTime = options.MaxTime
};
return(ExecuteReadOperation(operation, cancellationToken));
}
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedField = _field.Render(documentSerializer, serializerRegistry);
BsonValue value;
switch (_direction)
{
case SortDirection.Ascending:
value = 1;
break;
case SortDirection.Descending:
value = -1;
break;
default:
throw new InvalidOperationException("Unknown value for " + typeof(SortDirection) + ".");
}
return(new BsonDocument(renderedField.FieldName, value));
}
public override IAggregateFluent <TNewResult> Lookup <TNewResult>(string from, FieldDefinition <TResult> localField, FieldDefinition <BsonDocument> foreignField, FieldDefinition <TNewResult> @as, IBsonSerializer <TNewResult> newResultSerializer = null)
{
const string operatorName = "$lookup";
var stage = new DelegatedPipelineStageDefinition <TResult, TNewResult>(
operatorName,
(s, sr) =>
{
newResultSerializer = newResultSerializer ?? (s as IBsonSerializer <TNewResult>) ?? sr.GetSerializer <TNewResult>();
return(new RenderedPipelineStageDefinition <TNewResult>(
operatorName,
new BsonDocument(operatorName, new BsonDocument
{
{ "from", from },
{ "localField", localField.Render(s, sr).FieldName },
{ "foreignField", foreignField.Render(BsonDocumentSerializer.Instance, sr).FieldName },
{ "as", @as.Render(newResultSerializer, sr).FieldName },
}),
newResultSerializer));
});
return(AppendStage <TNewResult>(stage));
}
public override IAggregateFluent <TNewResult> Lookup <TForeignDocument, TNewResult>(string foreignCollectionName, FieldDefinition <TResult> localField, FieldDefinition <TForeignDocument> foreignField, FieldDefinition <TNewResult> @as, AggregateLookupOptions <TForeignDocument, TNewResult> options)
{
options = options ?? new AggregateLookupOptions <TForeignDocument, TNewResult>();
const string operatorName = "$lookup";
var stage = new DelegatedPipelineStageDefinition <TResult, TNewResult>(
operatorName,
(localSerializer, sr) =>
{
var foreignSerializer = options.ForeignSerializer ?? (localSerializer as IBsonSerializer <TForeignDocument>) ?? sr.GetSerializer <TForeignDocument>();
var newResultSerializer = options.ResultSerializer ?? (localSerializer as IBsonSerializer <TNewResult>) ?? sr.GetSerializer <TNewResult>();
return(new RenderedPipelineStageDefinition <TNewResult>(
operatorName, new BsonDocument(operatorName, new BsonDocument
{
{ "from", foreignCollectionName },
{ "localField", localField.Render(localSerializer, sr).FieldName },
{ "foreignField", foreignField.Render(foreignSerializer, sr).FieldName },
{ "as", @as.Render(newResultSerializer, sr).FieldName }
}),
newResultSerializer));
});
return(AppendStage <TNewResult>(stage));
}
public override IAggregateFluent <TNewResult> Unwind <TNewResult>(FieldDefinition <TResult> field, AggregateUnwindOptions <TNewResult> options)
{
options = options ?? new AggregateUnwindOptions <TNewResult>();
const string operatorName = "$unwind";
var stage = new DelegatedPipelineStageDefinition <TResult, TNewResult>(
operatorName,
(s, sr) =>
{
var newResultSerializer = options.ResultSerializer ?? (s as IBsonSerializer <TNewResult>) ?? sr.GetSerializer <TNewResult>();
var fieldName = "$" + field.Render(s, sr).FieldName;
string includeArrayIndexFieldName = null;
if (options.IncludeArrayIndex != null)
{
includeArrayIndexFieldName = options.IncludeArrayIndex.Render(newResultSerializer, sr).FieldName;
}
BsonValue value = fieldName;
if (options.PreserveNullAndEmptyArrays.HasValue || includeArrayIndexFieldName != null)
{
value = new BsonDocument
{
{ "path", fieldName },
{ "preserveNullAndEmptyArrays", options.PreserveNullAndEmptyArrays, options.PreserveNullAndEmptyArrays.HasValue },
{ "includeArrayIndex", includeArrayIndexFieldName, includeArrayIndexFieldName != null }
};
}
return(new RenderedPipelineStageDefinition <TNewResult>(
operatorName,
new BsonDocument(operatorName, value),
newResultSerializer));
});
return(AppendStage <TNewResult>(stage));
}
public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedField = _field.Render(sourceSerializer, serializerRegistry);
return(new BsonDocument(renderedField.FieldName, _value));
}
public override BsonDocument Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var renderedField = _field.Render(documentSerializer, serializerRegistry);
return(new BsonDocument(renderedField.FieldName, _type));
}
public override BsonDocument Render(IBsonSerializer <TSource> sourceSerializer, IBsonSerializerRegistry serializerRegistry, LinqProvider linqProvider)
{
var renderedField = _field.Render(sourceSerializer, serializerRegistry, linqProvider);
return(new BsonDocument(renderedField.FieldName + ".$", 1));
}
public override RenderedFieldDefinition Render(IBsonSerializer <TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
{
var rendered = _adaptee.Render(documentSerializer, serializerRegistry);
return(new RenderedFieldDefinition(rendered.FieldName, rendered.FieldSerializer));
}
