public static IAsyncDocumentQuery <TSource> Paging <TSource>(this IAsyncDocumentQuery <TSource> source, Request request)
{
var maxResultsPerPage = 50;
if (request.Query.per_page.HasValue)
{
maxResultsPerPage = request.Query.per_page;
}
if (maxResultsPerPage < 1)
{
maxResultsPerPage = 50;
}
var page = 1;
if (request.Query.page.HasValue)
{
page = request.Query.page;
}
if (page < 1)
{
page = 1;
}
var skipResults = (page - 1) * maxResultsPerPage;
return(source.Skip(skipResults)
.Take(maxResultsPerPage));
}
/// <summary>
/// Move the registered after query actions
/// </summary>
public void MoveAfterQueryExecuted <K>(IAsyncDocumentQuery <K> documentQuery)
{
if (afterQueryExecuted != null)
{
documentQuery.AfterQueryExecuted(afterQueryExecuted);
}
}
public YieldStream(AsyncDocumentSession parent, IAsyncDocumentQuery <T> query, FieldsToFetchToken fieldsToFetch, IAsyncEnumerator <BlittableJsonReaderObject> enumerator, CancellationToken token)
{
_parent = parent;
_enumerator = enumerator;
_token = token;
_query = query;
_fieldsToFetch = fieldsToFetch;
}
public static IAsyncDocumentQuery <TResult> WhereEquals <TResult, TValue, T>(this IAsyncDocumentQuery <TResult> self, Expression <Func <T, TValue> > propertySelector, TValue value)
{
AbstractDocumentQuery <TResult, AsyncDocumentQuery <TResult> > query = (AsyncDocumentQuery <TResult>)self;
query.WhereEquals(query.GetMemberQueryPath(propertySelector.Body), value);
return(self);
}
public static IAsyncDocumentQuery <TResult> Search <TResult, TValue, T>(this IAsyncDocumentQuery <TResult> self, Expression <Func <T, TValue> > propertySelector, string searchTerms, EscapeQueryOptions escapeQueryOptions = EscapeQueryOptions.RawQuery)
{
AbstractDocumentQuery <TResult, AsyncDocumentQuery <TResult> > query = (AsyncDocumentQuery <TResult>)self;
query.Search(query.GetMemberQueryPath(propertySelector.Body), searchTerms, escapeQueryOptions);
return(self);
}
public static IAsyncDocumentQuery <TResult> Highlight <TResult, TValue, T>(this IAsyncDocumentQuery <TResult> self, Expression <Func <T, TValue> > propertySelector, int fragmentLength, int fragmentCount, out FieldHighlightings highlightings)
{
AbstractDocumentQuery <TResult, AsyncDocumentQuery <TResult> > query = (AsyncDocumentQuery <TResult>)self;
query.Highlight(query.GetMemberQueryPath(propertySelector.Body), fragmentLength, fragmentCount, out highlightings);
return(self);
}
public YieldStream(AsyncDocumentSession parent, IAsyncDocumentQuery <T> query, string[] projectionFields, IAsyncEnumerator <BlittableJsonReaderObject> enumerator, CancellationToken token)
{
_parent = parent;
_enumerator = enumerator;
_token = token;
_query = query;
_projectionFields = projectionFields;
}
public async Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, Reference <QueryHeaderInformation> queryHeaderInformation)
{
var ravenQueryInspector = ((IRavenQueryInspector)query);
var indexQuery = ravenQueryInspector.GetIndexQuery(true);
var enumerator = await AsyncDatabaseCommands.StreamQueryAsync(ravenQueryInspector.AsyncIndexQueried, indexQuery, queryHeaderInformation);
var queryOperation = ((AsyncDocumentQuery <T>)query).InitializeQueryOperation(null);
queryOperation.DisableEntitiesTracking = true;
return(new QueryYieldStream <T>(this, enumerator, queryOperation));
}
public async Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, CancellationToken token = default(CancellationToken))
{
var streamOperation = new StreamOperation(this);
var command = streamOperation.CreateRequest((IRavenQueryInspector)query);
await RequestExecuter.ExecuteAsync(command, Context, token).ConfigureAwait(false);
var result = streamOperation.SetResultAsync(command.Result);
var queryOperation = ((AsyncDocumentQuery <T>)query).InitializeQueryOperation();
queryOperation.DisableEntitiesTracking = true;
return(new YieldStream <T>(this, result, token));
}
public async Task StreamIntoAsync <T>(IAsyncDocumentQuery <T> query, Stream output, CancellationToken token = default)
{
var streamOperation = new StreamOperation(this);
var command = streamOperation.CreateRequest(query.GetIndexQuery());
await RequestExecutor.ExecuteAsync(command, Context, SessionInfo, token).ConfigureAwait(false);
using (command.Result.Response)
using (command.Result.Stream)
{
await command.Result.Stream.CopyToAsync(output, 16 * 1024, token).ConfigureAwait(false);
}
}
public static IAsyncDocumentQuery <T> FilterByQueueAddress <T>(this IAsyncDocumentQuery <T> source, HttpRequestMessage request)
{
var queueAddress = request.GetQueryStringValue <string>("queueaddress");
if (string.IsNullOrWhiteSpace(queueAddress))
{
return(source);
}
source.AndAlso();
source.WhereEquals("QueueAddress", queueAddress.ToLowerInvariant());
return(source);
}
public static IAsyncDocumentQuery <TSource> Sort <TSource>(this IAsyncDocumentQuery <TSource> source, HttpRequestMessage request)
{
var descending = true;
var direction = request.GetQueryStringValue("direction", "desc");
if (direction == "asc")
{
descending = false;
}
string keySelector;
var sort = request.GetQueryStringValue("sort", "time_sent");
if (!AsyncDocumentQuerySortOptions.Contains(sort))
{
sort = "time_sent";
}
switch (sort)
{
case "id":
case "message_id":
keySelector = "MessageId";
break;
case "message_type":
keySelector = "MessageType";
break;
case "status":
keySelector = "Status";
break;
case "modified":
keySelector = "LastModified";
break;
case "time_of_failure":
keySelector = "TimeOfFailure";
break;
default:
keySelector = "TimeSent";
break;
}
return(source.AddOrder(keySelector, descending));
}
public async Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, CancellationToken token = default(CancellationToken))
{
var documentQuery = (AsyncDocumentQuery <T>)query;
var projectionFields = documentQuery.FieldsToFetchToken?.Projections;
var indexQuery = query.GetIndexQuery();
var streamOperation = new StreamOperation(this);
var command = streamOperation.CreateRequest(indexQuery);
await RequestExecutor.ExecuteAsync(command, Context, token, SessionInfo).ConfigureAwait(false);
var result = streamOperation.SetResultAsync(command.Result);
var queryOperation = ((AsyncDocumentQuery <T>)query).InitializeQueryOperation();
queryOperation.DisableEntitiesTracking = true;
return(new YieldStream <T>(this, query, projectionFields, result, token));
}
public async Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, Reference <QueryHeaderInformation> queryHeaderInformation, CancellationToken token = default(CancellationToken))
{
var ravenQueryInspector = ((IRavenQueryInspector)query);
var indexQuery = ravenQueryInspector.GetIndexQuery(true);
if (indexQuery.WaitForNonStaleResults || indexQuery.WaitForNonStaleResultsAsOfNow)
{
throw new NotSupportedException(
"Since Stream() does not wait for indexing (by design), streaming query with WaitForNonStaleResults is not supported.");
}
var enumerator = await AsyncDatabaseCommands.StreamQueryAsync(ravenQueryInspector.AsyncIndexQueried, indexQuery, queryHeaderInformation, token).ConfigureAwait(false);
var queryOperation = ((AsyncDocumentQuery <T>)query).InitializeQueryOperation();
queryOperation.DisableEntitiesTracking = true;
return(new QueryYieldStream <T>(this, enumerator, queryOperation, query, token));
}
public static IAsyncDocumentQuery <T> FilterByQueueAddress <T>(this IAsyncDocumentQuery <T> source, Request request)
{
string queueAddress = null;
if ((bool)request.Query.queueaddress.HasValue)
{
queueAddress = (string)request.Query.queueaddress;
}
if (string.IsNullOrWhiteSpace(queueAddress))
{
return(source);
}
source.AndAlso();
source.WhereEquals("QueueAddress", queueAddress.ToLowerInvariant());
return(source);
}
public static IAsyncDocumentQuery <TSource> Paging <TSource>(this IAsyncDocumentQuery <TSource> source, HttpRequestMessage request)
{
var maxResultsPerPage = request.GetQueryStringValue("per_page", 50);
if (maxResultsPerPage < 1)
{
maxResultsPerPage = 50;
}
var page = request.GetQueryStringValue("page", 1);
if (page < 1)
{
page = 1;
}
var skipResults = (page - 1) * maxResultsPerPage;
return(source.Skip(skipResults)
.Take(maxResultsPerPage));
}
public static IAsyncDocumentQuery <T> FilterByLastModifiedRange <T>(this IAsyncDocumentQuery <T> source, Request request)
{
string modified = null;
if ((bool)request.Query.modified.HasValue)
{
modified = (string)request.Query.modified;
}
if (modified == null)
{
return(source);
}
var filters = modified.Split(new[]
{
"..."
}, StringSplitOptions.None);
if (filters.Length != 2)
{
throw new Exception("Invalid modified date range, dates need to be in ISO8601 format and it needs to be a range eg. 2016-03-11T00:27:15.474Z...2016-03-16T03:27:15.474Z");
}
try
{
var from = DateTime.Parse(filters[0], CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
var to = DateTime.Parse(filters[1], CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
source.AndAlso();
source.WhereBetweenOrEqual("LastModified", from.Ticks, to.Ticks);
}
catch (Exception)
{
throw new Exception("Invalid modified date range, dates need to be in ISO8601 format and it needs to be a range eg. 2016-03-11T00:27:15.474Z...2016-03-16T03:27:15.474Z");
}
return(source);
}
private Task <IAsyncEnumerator <TimeSeriesStreamResult <T> > > TimeSeriesStreamInternalAsync <T>(IAsyncDocumentQuery <T> query, CancellationToken token) where T : ITimeSeriesQueryStreamResult, new()
{
return(TimeSeriesStreamInternalAsync(query, null, token));
}
/// <summary>
/// Async Query the facets results for this query using the specified facet document with the given start and pageSize
/// </summary>
/// <param name="facetSetupDoc">Name of the FacetSetup document</param>
/// <param name="start">Start index for paging</param>
/// <param name="pageSize">Paging PageSize. If set, overrides Facet.MaxResults</param>
public static Task <FacetResults> ToFacetsAsync <T>(this IAsyncDocumentQuery <T> queryable, string facetSetupDoc, int start = 0, int?pageSize = null)
{
return(queryable.GetFacetsAsync(facetSetupDoc, start, pageSize));
}
public Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, CancellationToken token = default(CancellationToken))
{
return(StreamAsync(query, new Reference <QueryHeaderInformation>(), token));
}
private Task <IAsyncEnumerator <TimeSeriesStreamResult <T> > > TimeSeriesStreamInternalAsync <T>(IAsyncDocumentQuery <T> query, out StreamQueryStatistics streamQueryStats, CancellationToken token) where T : ITimeSeriesQueryStreamResult, new()
{
streamQueryStats = new StreamQueryStatistics();
return(TimeSeriesStreamInternalAsync(query, streamQueryStats, token));
}
Task <IAsyncEnumerator <TimeSeriesStreamResult <TimeSeriesAggregationResult> > > IAsyncTimeSeriesSessionStreamOperations <TimeSeriesAggregationResult> .StreamAsync(IAsyncDocumentQuery <TimeSeriesAggregationResult> query, CancellationToken token)
{
return(TimeSeriesStreamInternalAsync(query, token));
}
public Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, CancellationToken token = default)
{
return(PerformQueryStreamOperation(query, null, token));
}
private async Task <IAsyncEnumerator <StreamResult <T> > > PerformQueryStreamOperation <T>(IAsyncDocumentQuery <T> query, StreamQueryStatistics streamQueryStats, CancellationToken token)
{
var documentQuery = (AsyncDocumentQuery <T>)query;
var fieldsToFetch = documentQuery.FieldsToFetchToken;
var indexQuery = query.GetIndexQuery();
var streamOperation = new StreamOperation(this, streamQueryStats);
var command = streamOperation.CreateRequest(indexQuery);
await RequestExecutor.ExecuteAsync(command, Context, SessionInfo, token).ConfigureAwait(false);
var result = streamOperation.SetResultAsync(command.Result);
var queryOperation = ((AsyncDocumentQuery <T>)query).InitializeQueryOperation();
queryOperation.NoTracking = true;
return(new YieldStream <T>(this, query, fieldsToFetch, result, token));
}
public static IAsyncDocumentQuery <T> FilterByStatusWhere <T>(this IAsyncDocumentQuery <T> source, Request request)
{
string status = null;
if ((bool)request.Query.status.HasValue)
{
status = (string)request.Query.status;
}
if (status == null)
{
return(source);
}
var filters = status.Replace(" ", String.Empty).Split(',');
var excludes = new List <int>();
var includes = new List <int>();
foreach (var filter in filters)
{
FailedMessageStatus failedMessageStatus;
if (filter.StartsWith("-"))
{
if (Enum.TryParse(filter.Substring(1), true, out failedMessageStatus))
{
excludes.Add((int)failedMessageStatus);
}
continue;
}
if (Enum.TryParse(filter, true, out failedMessageStatus))
{
includes.Add((int)failedMessageStatus);
}
}
var sb = new StringBuilder();
sb.Append("((");
if (includes.Count == 0)
{
sb.Append("*");
}
else
{
sb.Append(String.Join(" OR ", includes.ToArray()));
}
sb.Append(")");
if (excludes.Count > 0)
{
sb.Append(" AND NOT (");
sb.Append(String.Join(" OR ", excludes.ToArray()));
sb.Append(")");
}
sb.Append(")");
source.AndAlso();
source.Where($"Status: {sb}");
return(source);
}
public static IAsyncDocumentQuery <TSource> Sort <TSource>(this IAsyncDocumentQuery <TSource> source, Request request)
{
var direction = "desc";
var descending = true;
if (request.Query.direction.HasValue)
{
direction = (string)request.Query.direction;
}
if (direction == "asc")
{
descending = false;
}
var sortOptions = new[]
{
"id", "message_id", "message_type",
"time_sent", "status", "modified", "time_of_failure"
};
var sort = "time_sent";
string keySelector;
if (request.Query.sort.HasValue)
{
sort = (string)request.Query.sort;
}
if (!sortOptions.Contains(sort))
{
sort = "time_sent";
}
switch (sort)
{
case "id":
case "message_id":
keySelector = "MessageId";
break;
case "message_type":
keySelector = "MessageType";
break;
case "status":
keySelector = "Status";
break;
case "modified":
keySelector = "LastModified";
break;
case "time_of_failure":
keySelector = "TimeOfFailure";
break;
default:
keySelector = "TimeSent";
break;
}
return(source.AddOrder(keySelector, descending));
}
public Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query)
{
return(StreamAsync(query, new Reference <QueryHeaderInformation>()));
}
public QueryYieldStream(AsyncDocumentSession parent, IAsyncEnumerator <RavenJObject> enumerator, QueryOperation queryOperation, IAsyncDocumentQuery <T> query, CancellationToken token = default(CancellationToken))
: base(parent, enumerator, token)
{
this.queryOperation = queryOperation;
this.query = query;
}
public Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, Reference <QueryHeaderInformation> queryHeaderInformation)
{
throw new NotSupportedException("Streams are currently not supported by sharded document store");
}
public Task <IAsyncEnumerator <StreamResult <T> > > StreamAsync <T>(IAsyncDocumentQuery <T> query, out StreamQueryStatistics streamQueryStats, CancellationToken token = default)
{
streamQueryStats = new StreamQueryStatistics();
return(PerformQueryStreamOperation(query, streamQueryStats, token));
}
