public void use_distinct(IQuerySession session) { var surnames = session .Query<User>() .Select(x => x.LastName) .Distinct(); }
private async ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, TId> > > groupByConjoinedTenancy(IQuerySession querySession, List <IEvent> events) { var byTenant = events.GroupBy(x => x.TenantId); var groupTasks = byTenant.Select(async tGroup => { var tenant = new Tenant(tGroup.Key, querySession.Database); var tenantSession = querySession.ForTenant(tGroup.Key); var group = new TenantSliceGroup <TDoc, TId>(tenant); await GroupEvents(@group, tenantSession, tGroup.ToList()).ConfigureAwait(false); return(@group); }); var list = new List <TenantSliceGroup <TDoc, TId> >(); foreach (var groupTask in groupTasks) { list.Add(await groupTask.ConfigureAwait(false)); } return(list); }
public abstract Task Compare(IQuerySession session, Target[] documents);
public Task Get3(Guid issueId, [FromServices] IQuerySession session) { return(session.Query <Issue>().Where(x => x.Id == issueId) .WriteSingle(HttpContext)); }
public abstract ValueTask <T> BuildAsync(IReadOnlyList <IEvent> events, IQuerySession session, T?snapshot, CancellationToken cancellation);
public ValueTask <T> BuildAsync(IReadOnlyList <IEvent> events, IQuerySession session, T?snapshot, CancellationToken cancellation) { return(new(Build(events, session, snapshot))); }
public IMartenSessionLogger StartSession(IQuerySession session) { return(this); }
public ValueTask <IReadOnlyList <TenantSliceGroup <UserGroupsAssignment, Guid> > > SliceAsyncEvents(IQuerySession querySession, List <IEvent> events, ITenancy tenancy) { var group = new TenantSliceGroup <UserGroupsAssignment, Guid>(tenancy.Default); group.AddEvents <UserRegistered>(@event => @event.UserId, events); group.AddEvents <MultipleUsersAssignedToGroup>(@event => @event.UserIds, events); return(new(new List <TenantSliceGroup <UserGroupsAssignment, Guid> > { group })); }
public T Build(IReadOnlyList <IEvent> events, IQuerySession session, T?snapshot) { throw new NotSupportedException(); }
/// <summary> /// Initializes a new instance of <see cref="OrderedMartenDataStoreQueryable{T}"/>. /// </summary> public OrderedMartenDataStoreQueryable(IQuerySession session, IOrderedQueryable <T> source) : base(session, source) { }
public async Task <T> ResolveAsync(IIdentityMap map, IQuerySession session, CancellationToken token, object id) { var doc = await _parent.ResolveAsync(map, session, token, id).ConfigureAwait(false); return(doc as T); }
public T Resolve(IIdentityMap map, IQuerySession session, object id) { return(_parent.Resolve(map, session, id) as T); }
public async Task Apply(UserUpdated @event, MyAggregate aggregate, IQuerySession session) { var user = await session.LoadAsync <User>(@event.UserId); aggregate.UpdatedBy = user.UserName; }
// A shorthand for generating the required SQL statement for a sequence value query public static int NextInSequence(this IQuerySession session, Sequence sequence) { return(session.Query <int>("select nextval(?)", sequence.Identifier.QualifiedName).First()); }
public IMartenSessionLogger StartSession(IQuerySession session) { return new NulloMartenLogger(); }
protected abstract ValueTask GroupEvents(IEventGrouping <TId> grouping, IQuerySession session, List <IEvent> events);
public abstract ValueTask <TDoc> ApplyEvent(IQuerySession session, EventSlice <TDoc, TId> slice, IEvent evt, TDoc?aggregate, CancellationToken cancellationToken);
public ValueTask <IReadOnlyList <EventSlice <TDoc, string> > > SliceInlineActions(IQuerySession querySession, IEnumerable <StreamAction> streams, ITenancy tenancy) { return(new(streams.Select(s => { var tenant = tenancy.GetTenant(s.TenantId); return new EventSlice <TDoc, string>(s.Key !, tenant, s.Events); }).ToList())); }
public void Handle(LookupFakeDoc message, IQuerySession session) { }
public ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, string> > > SliceAsyncEvents(IQuerySession querySession, List <IEvent> events, ITenancy tenancy) { var list = new List <TenantSliceGroup <TDoc, string> >(); var byTenant = events.GroupBy(x => x.TenantId); foreach (var tenantGroup in byTenant) { var tenant = tenancy.GetTenant(tenantGroup.Key); var slices = tenantGroup .GroupBy(x => x.StreamKey) .Select(x => new EventSlice <TDoc, string>(x.Key !, tenant, x)); var group = new TenantSliceGroup <TDoc, string>(tenant, slices); list.Add(group); } return(new ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, string> > >(list)); }
public abstract T Build(IReadOnlyList <IEvent> events, IQuerySession session, T?snapshot);
/// <summary> /// Query by a user-supplied .Net document type and user-supplied SQL /// </summary> /// <param name="session"></param> /// <param name="type"></param> /// <param name="sql"></param> /// <param name="parameters"></param> /// <returns></returns> public static IReadOnlyList <object> Query(this IQuerySession session, Type type, string sql, params object[] parameters) { return((IReadOnlyList <object>)QueryMethod.MakeGenericMethod(type).Invoke(session, new object[] { sql, parameters })); }
public T Build(IReadOnlyList <IEvent> events, IQuerySession session, T?snapshot) { return(BuildAsync(events, session, snapshot, CancellationToken.None).GetAwaiter().GetResult()); }
public void Apply(AEvent a, MyAggregate aggregate, IQuerySession session) { }
public Task OpenIssues2([FromServices] IQuerySession session) { return(session.WriteArray(new OpenIssues(), HttpContext)); }
public Task <MyAggregate> Create(CreateEvent @event, IQuerySession session) { return(null); }
public Task <InnerAggregate> Apply(EventD @event, IQuerySession session) { return(Task.FromResult(this)); }
public Task <FakeAggregate> Apply(Event <SelfLiveAggregatorBuilderTests.EventE> @event, IQuerySession session) { return(Task.FromResult(this)); }
public virtual ValueTask <IReadOnlyList <EventSlice <TDoc, TId> > > SliceInlineActions(IQuerySession querySession, IEnumerable <StreamAction> streams) { throw new NotSupportedException("This projection can only be used with the Async lifecycle"); }
public SecureQuerySession(IQuerySession querySession, ISecurityQueryProvider securityQueryProvider, IMartenContext martenContext) { _querySession = querySession; _securityQueryProvider = securityQueryProvider; _martenContext = martenContext; }
private async ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, TId> > > groupBySingleTenant(IQuerySession querySession, List <IEvent> events) { // This path is for *NOT* conjoined multi-tenanted projections, but we have to respect per-database tenancy var group = new TenantSliceGroup <TDoc, TId>(querySession, Tenancy.DefaultTenantId); await GroupEvents(@group, querySession, events).ConfigureAwait(false); return(new List <TenantSliceGroup <TDoc, TId> > { @group }); }
public ValueTask <IReadOnlyList <EventSlice <UserGroupsAssignment, Guid> > > SliceInlineActions(IQuerySession querySession, IEnumerable <StreamAction> streams, ITenancy tenancy) { var allEvents = streams.SelectMany(x => x.Events).ToList(); var group = new TenantSliceGroup <UserGroupsAssignment, Guid>(tenancy.Default); group.AddEvents <UserRegistered>(@event => @event.UserId, allEvents); group.AddEvents <MultipleUsersAssignedToGroup>(@event => @event.UserIds, allEvents); return(new(group.Slices.ToList())); }
public IMartenSessionLogger StartSession(IQuerySession session) { return this; }
public HomeEndpoint(IQuerySession session) { _session = session; }