/// <summary>
/// Executes a table query and processes the results as they arrive.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="processResultAsync"></param>
/// <param name="cancellationToken"></param>
public static async Task ForEachQueryResultAsync <T>(
this TableQuery <T> query,
Func <T, Task <bool> > processResultAsync,
CancellationToken cancellationToken = default) where T : ITableEntity, new()
{
TableContinuationToken?token = null;
var count = 0;
do
{
var seg = await query.ExecuteSegmentedAsync(token);
token = seg.ContinuationToken;
foreach (var result in seg)
{
if (!await processResultAsync(result))
{
break;
}
count++;
}
}while (token != null && !cancellationToken.IsCancellationRequested && (query.TakeCount == null || count < query.TakeCount.Value));
}
/// <summary>
/// Read data entries and their corresponding eTags from the Azure table.
/// </summary>
/// <param name="predicate">Predicate function to use for querying the table and filtering the results.</param>
/// <returns>Enumeration of entries in the table which match the query condition.</returns>
public async Task <IEnumerable <Tuple <T, string> > > ReadTableEntriesAndEtagsAsync(Expression <Func <T, bool> > predicate)
{
const string operation = "ReadTableEntriesAndEtags";
var startTime = DateTime.UtcNow;
try
{
TableQuery <T> cloudTableQuery = predicate == null
? tableReference.CreateQuery <T>()
: tableReference.CreateQuery <T>().Where(predicate).AsTableQuery();
try
{
Func <Task <List <T> > > executeQueryHandleContinuations = async() =>
{
TableQuerySegment <T> querySegment = null;
var list = new List <T>();
while (querySegment == null || querySegment.ContinuationToken != null)
{
querySegment = await cloudTableQuery.ExecuteSegmentedAsync(querySegment?.ContinuationToken);
list.AddRange(querySegment);
}
return(list);
};
IBackoffProvider backoff = new FixedBackoff(AzureTableDefaultPolicies.PauseBetweenTableOperationRetries);
List <T> results = await AsyncExecutorWithRetries.ExecuteWithRetries(
counter => executeQueryHandleContinuations(),
AzureTableDefaultPolicies.MaxTableOperationRetries,
(exc, counter) => AzureStorageUtils.AnalyzeReadException(exc.GetBaseException(), counter, TableName, Logger),
AzureTableDefaultPolicies.TableOperationTimeout,
backoff);
// Data was read successfully if we got to here
return(results.Select(i => Tuple.Create(i, i.ETag)).ToList());
}
catch (Exception exc)
{
// Out of retries...
var errorMsg = $"Failed to read Azure storage table {TableName}: {exc.Message}";
if (!AzureStorageUtils.TableStorageDataNotFound(exc))
{
Logger.Warn(ErrorCode.AzureTable_09, errorMsg, exc);
}
throw new OrleansException(errorMsg, exc);
}
}
finally
{
CheckAlertSlowAccess(startTime, operation);
}
}
public static async IAsyncEnumerable <T> ExecuteAsync <T>(this TableQuery <T> query, [EnumeratorCancellation] CancellationToken token = default)
{
TableQuerySegment <T> segment;
do
{
segment = await query.ExecuteSegmentedAsync(null, token);
foreach (var result in segment.Results)
{
yield return(result);
}
} while (segment.ContinuationToken != null && !token.IsCancellationRequested);
}
public static async Task <IList <T> > ExecuteQueryAsync <T>(this TableQuery <T> query, CancellationToken ct = default(CancellationToken)) where T : ITableEntity, new()
{
var items = new List <T>();
TableContinuationToken token = null;
do
{
TableQuerySegment <T> seg = await query.ExecuteSegmentedAsync(token).ContinueOnAnyContext();
token = seg.ContinuationToken;
items.AddRange(seg);
} while (token != null && !ct.IsCancellationRequested && (query.TakeCount == null || items.Count < query.TakeCount.Value));
return(items);
}
async Task <List <T> > _querySegment(TableQuery <T> query)
{
TableQuerySegment <T> querySegment = null;
var returnList = new List <T>();
while (querySegment == null || querySegment.ContinuationToken != null)
{
querySegment = await query
.ExecuteSegmentedAsync(querySegment != null?
querySegment.ContinuationToken : null);
if (querySegment.Results != null)
{
returnList.AddRange(querySegment.Results);
}
}
return(returnList);
}
private async Task <IList <TResult> > ExecuteAsync <TResult>(TableQuery <TResult> query)
{
TableContinuationToken continuationToken = null;
IList <TResult> results = new List <TResult>();
do
{
var res = await query.ExecuteSegmentedAsync(continuationToken);
foreach (var item in res)
{
results.Add(item);
}
continuationToken = res.ContinuationToken;
} while (continuationToken != null);
return(results);
}
/// <summary>
/// Executes a table query and processes the results as they arrive
/// </summary>
public static async Task ForEachQueryResultAsync <T>(this TableQuery <T> query, Func <T, Task> processResultAsync, CancellationToken ct = default(CancellationToken)) where T : ITableEntity, new()
{
TableContinuationToken token = null;
int count = 0;
do
{
TableQuerySegment <T> seg = await query.ExecuteSegmentedAsync(token).ContinueOnAnyContext();
token = seg.ContinuationToken;
foreach (var result in seg)
{
await processResultAsync(result).ContinueOnAnyContext();
count++;
}
} while (token != null && !ct.IsCancellationRequested && (query.TakeCount == null || count < query.TakeCount.Value));
}
/// <summary>
/// Gets all entities from the table.
/// </summary>
/// <returns>An enumerable of all stored entities.</returns>
public async Task <IEnumerable <T> > GetAll()
{
TableQuery <T> query = (from map in this.table.CreateQuery <T>() select map).AsTableQuery <T>();
Func <TableContinuationToken, Task <TableQuerySegment <T> > > queryExecute = (token) => query.ExecuteSegmentedAsync(token);
return(await ExecuteQuery(queryExecute));
}