public async Task <long> ProjectionProgressFor(ShardName name,
CancellationToken token = default)
{
await EnsureStorageExistsAsync(typeof(IEvent), token).ConfigureAwait(false);
var statement = new ProjectionProgressStatement(_options.EventGraph)
{
Name = name
};
var handler = new OneResultHandler <ShardState>(statement,
new ShardStateSelector(), true, false);
await using var conn = CreateConnection();
await conn.OpenAsync(token).ConfigureAwait(false);
var builder = new CommandBuilder();
handler.ConfigureCommand(builder, null);
await using var reader = await builder.ExecuteReaderAsync(conn, token).ConfigureAwait(false);
var state = await handler.HandleAsync(reader, null, token).ConfigureAwait(false);
return(state?.Sequence ?? 0);
}
public Task <T> SingleOrDefault <T>(IMartenQueryable <T> queryable)
{
var expression = queryable.Expression;
var query = QueryParser.GetParsedQuery(expression);
return(AddItem(OneResultHandler <T> .SingleOrDefault(_schema, query, queryable.Includes.ToArray())));
}
public async Task <long> ProjectionProgressFor(ShardName name, CancellationToken token = default)
{
await _store.Tenancy.Default.EnsureStorageExistsAsync(typeof(IEvent), token);
var statement = new ProjectionProgressStatement(_store.Events)
{
Name = name
};
var handler = new OneResultHandler <ShardState>(statement,
new ShardStateSelector(), true, false);
await using var session = (QuerySession)_store.QuerySession();
var progress = await session.ExecuteHandlerAsync(handler, token);
return(progress?.Sequence ?? 0);
}
/// <summary>
/// Check the current progress of a single projection or projection shard
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public async Task <long> ProjectionProgressFor(string projectionOrShardName, CancellationToken token = default(CancellationToken))
{
_store.Tenancy.Default.EnsureStorageExists(typeof(IEvent));
var statement = new ProjectionProgressStatement(this)
{
ProjectionOrShardName = projectionOrShardName
};
var handler = new OneResultHandler <ProjectionProgress>(statement,
new ProjectionProgressSelector(), true, false);
await using var session = (QuerySession)_store.QuerySession();
var progress = await session.ExecuteHandlerAsync(handler, token);
return(progress?.LastSequenceId ?? 0);
}
private IQueryHandler toDiagnosticHandler(FetchType fetchType)
{
switch (fetchType)
{
case FetchType.Count:
return(ToLinqQuery().ToCount <int>());
case FetchType.Any:
return(ToLinqQuery().ToAny());
case FetchType.FetchMany:
return(ToLinqQuery().ToList());
case FetchType.FetchOne:
return(OneResultHandler <T> .First(ToLinqQuery()));
}
throw new ArgumentOutOfRangeException(nameof(fetchType));
}
private IQueryHandler toDiagnosticHandler(QueryModel model, FetchType fetchType)
{
switch (fetchType)
{
case FetchType.Count:
return(new CountQueryHandler <int>(model, Schema));
case FetchType.Any:
return(new AnyQueryHandler(model, Schema));
case FetchType.FetchMany:
return(new LinqQueryHandler <T>(Schema, model, Includes.ToArray(), Statistics));
case FetchType.FetchOne:
return(OneResultHandler <T> .First(Schema, model, Includes.ToArray()));
}
throw new ArgumentOutOfRangeException(nameof(fetchType));
}
public Task <T> SingleOrDefault <T>(IMartenQueryable <T> queryable)
{
var query = queryable.ToLinqQuery();
return(AddItem(OneResultHandler <T> .SingleOrDefault(query), queryable.Statistics));
}
public Task <TResult> SingleOrDefaultAsync <TResult>(CancellationToken token)
{
return(executeAsync(q => OneResultHandler <TResult> .SingleOrDefault(q.As <LinqQuery <TResult> >()), token));
}
public Task <TResult> FirstAsync <TResult>(CancellationToken token)
{
return(executeAsync(q => OneResultHandler <TResult> .First(q.As <LinqQuery <TResult> >()), token));
}
public Task <TResult> SingleOrDefaultAsync <TResult>(CancellationToken token)
{
return(executeAsync(q => OneResultHandler <TResult> .SingleOrDefault(Schema, q, Includes.ToArray()), token));
}
