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;
}
