/// <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) { }