FindFluent.cs

/* Copyright 2010-present MongoDB Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

usingSystem;
usingSystem.Text;
usingSystem.Threading;
usingSystem.Threading.Tasks;
usingMongoDB.Bson.Serialization;
usingMongoDB.Driver.Core.Misc;

namespaceMongoDB.Driver
{
internalclassFindFluent<TDocument,TProjection>:FindFluentBase<TDocument,TProjection>
{
// private fields
privatereadonlyIMongoCollection<TDocument>_collection;
privateFilterDefinition<TDocument>_filter;
privatereadonlyFindOptions<TDocument,TProjection>_options;
privatereadonlyIClientSessionHandle_session;

// constructors
publicFindFluent(IClientSessionHandlesession,IMongoCollection<TDocument>collection,FilterDefinition<TDocument>filter,FindOptions<TDocument,TProjection>options)
{
_session=session;// can be null
_collection=Ensure.IsNotNull(collection,nameof(collection));
_filter=Ensure.IsNotNull(filter,nameof(filter));
_options=Ensure.IsNotNull(options,nameof(options));
}

// public properties
publicoverrideFilterDefinition<TDocument>Filter
{
get{return_filter;}
set{_filter=Ensure.IsNotNull(value,nameof(value));}
}

publicoverrideFindOptions<TDocument,TProjection>Options
{
get{return_options;}
}

// public methods
publicoverrideIFindFluent<TDocument,TResult>As<TResult>(IBsonSerializer<TResult>resultSerializer)
{
varprojection=Builders<TDocument>.Projection.As<TResult>(resultSerializer);
returnProject(projection);
}

[Obsolete("Use CountDocuments instead.")]
publicoverridelongCount(CancellationTokencancellationToken)
{
varoptions=CreateCountOptions();
if(_session==null)
{
return_collection.Count(_filter,options,cancellationToken);
}
else
{
return_collection.Count(_session,_filter,options,cancellationToken);
}
}

[Obsolete("Use CountDocumentsAsync instead.")]
publicoverrideTask<long>CountAsync(CancellationTokencancellationToken)
{
varoptions=CreateCountOptions();
if(_session==null)
{
return_collection.CountAsync(_filter,options,cancellationToken);
}
else
{
return_collection.CountAsync(_session,_filter,options,cancellationToken);
}
}

publicoverridelongCountDocuments(CancellationTokencancellationToken)
{
varoptions=CreateCountOptions();
if(_session==null)
{
return_collection.CountDocuments(_filter,options,cancellationToken);
}
else
{
return_collection.CountDocuments(_session,_filter,options,cancellationToken);
}
}

publicoverrideTask<long>CountDocumentsAsync(CancellationTokencancellationToken)
{
varoptions=CreateCountOptions();
if(_session==null)
{
return_collection.CountDocumentsAsync(_filter,options,cancellationToken);
}
else
{
return_collection.CountDocumentsAsync(_session,_filter,options,cancellationToken);
}
}

publicoverrideIFindFluent<TDocument,TProjection>Limit(int?limit)
{
_options.Limit=limit;
returnthis;
}

publicoverrideIFindFluent<TDocument,TNewProjection>Project<TNewProjection>(ProjectionDefinition<TDocument,TNewProjection>projection)
{
varnewOptions=newFindOptions<TDocument,TNewProjection>
{
AllowDiskUse=_options.AllowDiskUse,
AllowPartialResults=_options.AllowPartialResults,
BatchSize=_options.BatchSize,
Collation=_options.Collation,
Comment=_options.Comment,
CursorType=_options.CursorType,
Hint=_options.Hint,
Let=_options.Let,
Limit=_options.Limit,
Max=_options.Max,
MaxAwaitTime=_options.MaxAwaitTime,
MaxTime=_options.MaxTime,
Min=_options.Min,
NoCursorTimeout=_options.NoCursorTimeout,
#pragma warning disable 618
OplogReplay=_options.OplogReplay,
#pragma warning restore 618
Projection=projection,
ReturnKey=_options.ReturnKey,
ShowRecordId=_options.ShowRecordId,
Skip=_options.Skip,
Sort=_options.Sort,
TranslationOptions=_options.TranslationOptions
};
returnnewFindFluent<TDocument,TNewProjection>(_session,_collection,_filter,newOptions);
}

publicoverrideIFindFluent<TDocument,TProjection>Skip(int?skip)
{
_options.Skip=skip;
returnthis;
}

publicoverrideIFindFluent<TDocument,TProjection>Sort(SortDefinition<TDocument>sort)
{
_options.Sort=sort;
returnthis;
}

publicoverrideIAsyncCursor<TProjection>ToCursor(CancellationTokencancellationToken=default(CancellationToken))
{
if(_session==null)
{
return_collection.FindSync(_filter,_options,cancellationToken);
}
else
{
return_collection.FindSync(_session,_filter,_options,cancellationToken);
}
}

publicoverrideTask<IAsyncCursor<TProjection>>ToCursorAsync(CancellationTokencancellationToken=default(CancellationToken))
{
if(_session==null)
{
return_collection.FindAsync(_filter,_options,cancellationToken);
}
else
{
return_collection.FindAsync(_session,_filter,_options,cancellationToken);
}
}

publicoverridestringToString()
{
returnToString(translationOptions:null);
}

publicoverridestringToString(ExpressionTranslationOptionstranslationOptions)
{
varsb=newStringBuilder("find(");
varrenderedFilter=Render(_filter.Render,translationOptions);
sb.Append(renderedFilter.ToString());

if(_options.Projection!=null)
{
varrenderedProjection=Render(_options.Projection.Render,translationOptions,renderForFind:true);
if(renderedProjection.Document!=null)
{
sb.Append(", "+renderedProjection.Document.ToString());
}
}
sb.Append(")");

if(_options.Collation!=null)
{
sb.Append(".collation("+_options.Collation.ToString()+")");
}

if(_options.Sort!=null)
{
varrenderedSort=Render(_options.Sort.Render,translationOptions);
sb.Append(".sort("+renderedSort.ToString()+")");
}

if(_options.Skip.HasValue)
{
sb.Append(".skip("+_options.Skip.Value.ToString()+")");
}

if(_options.Limit.HasValue)
{
sb.Append(".limit("+_options.Limit.Value.ToString()+")");
}

if(_options.MaxTime!=null)
{
sb.Append(".maxTime("+_options.MaxTime.Value.TotalMilliseconds+")");
}

if(_options.Hint!=null)
{
sb.Append(".hint("+_options.Hint+")");
}

if(_options.Max!=null)
{
sb.Append(".max("+_options.Max+")");
}

if(_options.Min!=null)
{
sb.Append(".min("+_options.Min+")");
}

if(_options.ReturnKey.HasValue)
{
sb.Append(".returnKey("+_options.ReturnKey.Value.ToString().ToLower()+")");
}

if(_options.ShowRecordId.HasValue)
{
sb.Append(".showRecordId("+_options.ShowRecordId.Value.ToString().ToLower()+")");
}

if(_options.Comment!=null)
{
sb.Append("._addSpecial(\"$comment\", \""+_options.Comment+"\")");
}

returnsb.ToString();
}

// private methods
privateCountOptionsCreateCountOptions()
{
returnnewCountOptions
{
Collation=_options.Collation,
Hint=_options.Hint,
Limit=_options.Limit,
MaxTime=_options.MaxTime,
Skip=_options.Skip
};
}

privateTRenderedRender<TRendered>(Func<RenderArgs<TDocument>,TRendered>renderer,ExpressionTranslationOptionstranslationOptions,boolrenderForFind=false)
{
varargs=newRenderArgs<TDocument>(
_collection.DocumentSerializer,
_collection.Settings.SerializerRegistry,
renderForFind:renderForFind,
translationOptions:translationOptions);

returnrenderer(args);
}
}
}