/// <summary>
/// Aggregate the events in this query to the type T
/// </summary>
/// <param name="queryable"></param>
/// <param name="state"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T AggregateTo <T>(this IMartenQueryable <IEvent> queryable, T state = null) where T : class
{
var events = queryable.ToList();
if (!events.Any())
{
return(null);
}
var session = queryable.As <MartenLinqQueryable <IEvent> >().Session;
var aggregator = session.Options.Projections.AggregatorFor <T>();
var aggregate = aggregator.Build(queryable.ToList(), session, state);
return(aggregate);
}
public IBatchedQueryable <T> Include <TInclude>(Expression <Func <T, object> > idSource, IList <TInclude> list) where TInclude : class
{
_inner = _inner.Include(idSource, list);
return(this);
}
public IBatchedQueryable <T> Include <TInclude>(Expression <Func <T, object> > idSource, Action <TInclude> callback) where TInclude : class
{
_inner = _inner.Include(idSource, callback);
return(this);
}
public PractitionerIncludeMapper(IMartenQueryable <Practitioner> queryable) : base(queryable)
{
}
public Task <long> Count <TDoc>(IMartenQueryable <TDoc> queryable)
{
return(AddItem(queryable.ToLinqQuery().ToCount <long>(), null));
}
public TransformedBatchQueryable(BatchedQuery parent, IMartenQueryable <TValue> inner)
{
_parent = parent;
_inner = inner;
}
public Task <T> First <T>(IMartenQueryable <T> queryable)
{
return(addItem <T, T>(queryable, LinqConstants.FirstOperator));
}
public Task <long> Count <TDoc>(IMartenQueryable <TDoc> queryable)
{
return(addItem <TDoc, long>(queryable, LinqConstants.LongCountOperator));
}
public static IQueryable<string> AsJson<T>(this IMartenQueryable<T> queryable)
{
return queryable.Select(x => x.AsJson());
}
public BatchedOrderedQueryable(BatchedQuery parent, IMartenQueryable <T> inner) : base(parent, inner)
{
}
public MartenDataQuery(IMartenQueryable <T> queryable) => _queryable = queryable;
/// <summary>
/// Aggregate the events in this query to the type T
/// </summary>
/// <param name="queryable"></param>
/// <param name="state"></param>
/// <param name="token"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static async Task <T> AggregateToAsync <T>(this IMartenQueryable <IEvent> queryable, T state = null,
CancellationToken token = new ()) where T : class
public IBatchedQueryable <T> Include <TInclude, TKey>(Expression <Func <T, object> > idSource, IDictionary <TKey, TInclude> dictionary,
JoinType joinType = JoinType.Inner) where TInclude : class
{
_inner = _inner.Include(idSource, dictionary, joinType);
return(this);
}
public IBatchedQueryable <T> Include <TInclude, TKey>(Expression <Func <T, object> > idSource,
IDictionary <TKey, TInclude> dictionary) where TKey : notnull where TInclude : class
{
_inner = _inner.Include(idSource, dictionary);
return(this);
}
public BatchedQueryable(BatchedQuery parent, IMartenQueryable <T> inner)
{
_parent = parent;
_inner = inner;
}
public Task <bool> Any <TDoc>(IMartenQueryable <TDoc> queryable)
{
return(addItem <TDoc, bool>(queryable, LinqConstants.AnyOperator));
}
public IBatchedQueryable <T> Stats(out QueryStatistics stats)
{
_inner = _inner.Stats(out stats);
return(this);
}
internal Task <IReadOnlyList <T> > Query <T>(IMartenQueryable <T> queryable)
{
var handler = queryable.As <MartenLinqQueryable <T> >().BuildHandler <IReadOnlyList <T> >();
return(AddItem(handler));
}
public IBatchedQueryable <T> Where(Expression <Func <T, bool> > predicate)
{
_inner = _inner.Where(predicate).As <IMartenQueryable <T> >();
return(this);
}
public Task <T> SingleOrDefault <T>(IMartenQueryable <T> queryable)
{
return(addItem <T, T>(queryable, LinqConstants.SingleOrDefaultOperator));
}
public IBatchedQueryable <T> Take(int count)
{
_inner = _inner.Take(count).As <IMartenQueryable <T> >();
return(this);
}
public Task <bool> Any <TDoc>(IMartenQueryable <TDoc> queryable)
{
return(AddItem(queryable.ToLinqQuery().ToAny(), null));
}
public IBatchedQueryable <T> OrderByDescending <TKey>(Expression <Func <T, TKey> > expression)
{
_inner = _inner.OrderByDescending(expression).As <IMartenQueryable <T> >();
return(this);
}
public Task <T> SingleOrDefault <T>(IMartenQueryable <T> queryable)
{
var query = queryable.ToLinqQuery();
return(AddItem(OneResultHandler <T> .SingleOrDefault(query), queryable.Statistics));
}
public PracticeIncludeMapper(IMartenQueryable <Practice> queryable) : base(queryable)
{
}
