public Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token, ResultOperatorBase op)
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
return(ExecuteHandlerAsync(handler, token));
}
public IQueryHandler <TResult> BuildHandler <TResult>(IMartenSession session, Statement statement,
Statement currentStatement)
{
var selector = (ISelector <T>)BuildSelector(session);
return(LinqHandlerBuilder.BuildHandler <T, TResult>(selector, statement));
}
public TResult Execute <TResult>(Expression expression, ResultOperatorBase op)
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
return(ExecuteHandler(handler));
}
public TResult Execute <TResult>(Expression expression)
{
var builder = new LinqHandlerBuilder(_session, expression);
var handler = builder.BuildHandler <TResult>(Statistics);
return(ExecuteHandler(handler));
}
public IQueryHandler <TResult> BuildHandler <TResult>(IMartenSession session, Statement statement,
Statement currentStatement)
{
var selector = new SerializationSelector <T>(session.Serializer);
return(LinqHandlerBuilder.BuildHandler <T, TResult>(selector, statement));
}
private void ensureStorageExists(LinqHandlerBuilder builder)
{
foreach (var documentType in builder.DocumentTypes())
{
_session.Database.EnsureStorageExists(documentType);
}
}
public Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token)
{
var builder = new LinqHandlerBuilder(_session, expression);
var handler = builder.BuildHandler <TResult>(Statistics);
return(ExecuteHandlerAsync(handler, token));
}
/// <summary>
/// Builds out a LinqHandlerBuilder for this MartenQueryable<T>
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
internal LinqHandlerBuilder BuildLinqHandler(Expression expression)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
builder.BuildDatabaseStatement();
return(builder);
}
public TResult Execute <TResult>(Expression expression)
{
var builder = new LinqHandlerBuilder(this, expression);
var handler = builder.BuildHandler <TResult>();
// TODO -- worry about QueryStatistics later
return(executeHandler(handler, null));
}
private async ValueTask ensureStorageExistsAsync(LinqHandlerBuilder builder,
CancellationToken cancellationToken)
{
foreach (var documentType in builder.DocumentTypes())
{
await _session.Database.EnsureStorageExistsAsync(documentType, cancellationToken).ConfigureAwait(false);
}
}
public Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, expression);
var handler = builder.BuildHandler <TResult>();
// TODO -- worry about QueryStatistics later
return(executeHandlerAsync(handler, null, token));
}
public async Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
var handler = builder.BuildHandler <TResult>();
await ensureStorageExistsAsync(builder, token).ConfigureAwait(false);
return(await ExecuteHandlerAsync(handler, token).ConfigureAwait(false));
}
public TResult Execute <TResult>(Expression expression)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
var handler = builder.BuildHandler <TResult>();
ensureStorageExists(builder);
return(ExecuteHandler(handler));
}
public Task StreamMany(Expression expression, Stream destination, CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
builder.BuildDatabaseStatement();
var command = builder.TopStatement.BuildCommand();
return(_session.Database.StreamMany(command, destination, token));
}
public async Task <int> StreamJson <TResult>(Stream stream, Expression expression, CancellationToken token, ResultOperatorBase op)
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
var cmd = _session.BuildCommand(handler);
using var reader = await _session.ExecuteReaderAsync(cmd, token).ConfigureAwait(false);
return(await handler.StreamJson(stream, reader, token).ConfigureAwait(false));
}
public Task <bool> StreamOne(Expression expression, Stream destination, CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
builder.BuildDatabaseStatement();
var statement = builder.TopStatement;
statement.Current().Limit = 1;
var command = statement.BuildCommand();
return(_session.StreamOne(command, destination, token));
}
public async Task <bool> StreamOne(Expression expression, Stream destination, CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
builder.BuildDatabaseStatement();
await ensureStorageExistsAsync(builder, token).ConfigureAwait(false);
var statement = builder.TopStatement;
statement.Current().Limit = 1;
var command = statement.BuildCommand();
return(await _session.StreamOne(command, destination, token).ConfigureAwait(false));
}
public static LinqHandlerBuilder BuildDatabaseCommand <TDoc, TOut>(IMartenSession session,
ICompiledQuery <TDoc, TOut> queryTemplate,
QueryStatistics statistics,
out NpgsqlCommand command)
{
Expression expression = queryTemplate.QueryIs();
var invocation = Expression.Invoke(expression, Expression.Parameter(typeof(IMartenQueryable <TDoc>)));
var builder = new LinqHandlerBuilder(session, invocation, forCompiled: true);
command = builder.BuildDatabaseCommand(statistics);
return(builder);
}
public async Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken token, ResultOperatorBase op)
{
try
{
var builder = new LinqHandlerBuilder(this, _session, expression, op);
var handler = builder.BuildHandler <TResult>();
await ensureStorageExistsAsync(builder, token).ConfigureAwait(false);
return(await ExecuteHandlerAsync(handler, token).ConfigureAwait(false));
}
catch (Exception e)
{
MartenExceptionTransformer.WrapAndThrow(e);
}
return(default);
public async IAsyncEnumerable <T> ExecuteAsyncEnumerable <T>(Expression expression, [EnumeratorCancellation] CancellationToken token)
{
var builder = new LinqHandlerBuilder(this, _session, expression);
builder.BuildDatabaseStatement();
var selector = (ISelector <T>)builder.CurrentStatement.SelectClause.BuildSelector(_session);
var statement = builder.TopStatement;
var cmd = _session.BuildCommand(statement);
using var reader = await _session.ExecuteReaderAsync(cmd, token).ConfigureAwait(false);
while (await reader.ReadAsync(token).ConfigureAwait(false))
{
yield return(await selector.ResolveAsync(reader, token).ConfigureAwait(false));
}
}
public IQueryHandler <TResult> BuildHandler <TResult>(IMartenSession session, Statement statement,
Statement currentStatement)
{
return(LinqHandlerBuilder.BuildHandler <string, TResult>(this, statement));
}
public IQueryHandler <T> BuildHandler <T>(IMartenSession session, Statement topStatement, Statement currentStatement)
{
return(LinqHandlerBuilder.BuildHandler <IEvent, T>(this, topStatement));
}
internal IQueryHandler <TResult> BuildHandler <TResult>(ResultOperatorBase op = null)
{
var builder = new LinqHandlerBuilder(_session, Expression, op);
return(builder.BuildHandler <TResult>(Statistics));
}
internal IQueryHandler <TResult> BuildHandler <TResult>(ResultOperatorBase?op = null)
{
var builder = new LinqHandlerBuilder(MartenProvider, Session, Expression, op);
return(builder.BuildHandler <TResult>());
}
