public static async Task DeletePartitionKeyAsync(CloudTable table, string partitionKey)
{
try
{
// Create the range query using the fluid API
TableQuery <TableEntity> rangeQuery = new TableQuery <TableEntity>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey)
);
TableContinuationToken token = null;
rangeQuery.TakeCount = 100;
int segmentNumber = 0;
do
{
TableQuerySegment <TableEntity> segment = await table.ExecuteQuerySegmentedAsync(rangeQuery, token);
if (segment.Results.Count > 0)
{
segmentNumber++;
Console.WriteLine();
Console.WriteLine("Deleting segment {0}", segmentNumber);
IList <ITableEntity> deleteThese = segment.ToList <ITableEntity>();
DeleteBatch(deleteThese, table);
}
// Save the continuation token for the next call to ExecuteQuerySegmentedAsync
token = segment.ContinuationToken;
}while (token != null);
}
catch (StorageException e)
{
Console.WriteLine(e.Message);
Console.ReadLine();
throw;
}
}
public static List <T> ListarCotacoes <T>(IConfiguration config,
string siglaMoeda) where T : CotacaoEntity, new()
{
// Acessar configurações
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
config["StorageConnectionString"]);
// Obter referência da tabela
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("Cotacoes");
TableQuery <T> query = new TableQuery <T>().Where(
TableQuery.GenerateFilterCondition(
"PartitionKey", QueryComparisons.Equal, siglaMoeda));
// Obtém os resultados em segmentos
List <T> cotacoes = new List <T>();
TableContinuationToken continuationToken = null;
do
{
Task <TableQuerySegment <T> > task =
table.ExecuteQuerySegmentedAsync(
query, continuationToken);
TableQuerySegment <T> querySegment = task.Result;
cotacoes.AddRange(querySegment.ToList());
continuationToken = querySegment.ContinuationToken;
} while (continuationToken != null);
return(cotacoes);
}
public static List <T> ExecuteQuery <T>(CloudTable table, TableQuery <T> query) where T : ITableEntity, new()
{
TableContinuationToken continuationToken = null;
TableQuerySegment <T> tableQueryResult =
AsyncContext.Run(() => table.ExecuteQuerySegmentedAsync(query, continuationToken));
return(tableQueryResult.ToList());
}
public async Task <List <T> > ReadAsync <T>(string tableName) where T : ITableEntity, new()
{
CloudTable table = client.GetTableReference(tableName);
await table.CreateIfNotExistsAsync();
var query = new TableQuery <T>();
TableQuerySegment <T> segment = await table.ExecuteQuerySegmentedAsync(query, new TableContinuationToken());
if (!(segment == null || segment.Results.Count == 0))
{
return(segment.ToList());
}
return(null);
}
public List <CustomerEntity> All()
{
TableQuery <CustomerEntity> tableQuery = new TableQuery <CustomerEntity>();
TableContinuationToken continuationToken = null;
var fullList = new List <CustomerEntity>();
do
{
TableQuerySegment <CustomerEntity> result = _azureTable.ExecuteQuerySegmented(tableQuery, continuationToken);
continuationToken = result.ContinuationToken;
var customerList = result as IList <CustomerEntity> ?? result.ToList();
fullList.AddRange(customerList);
} while (continuationToken != null);
return(fullList);
}
public async Task <List <T> > ReadAsync <T>(string tableName, string fieldName, string operation, string value) where T : ITableEntity, new()
{
CloudTable table = client.GetTableReference(tableName);
await table.CreateIfNotExistsAsync();
var query = new TableQuery <T>().Where(TableQuery.GenerateFilterCondition(fieldName, operation, value));
TableQuerySegment <T> segment = await table.ExecuteQuerySegmentedAsync <T>(query, new TableContinuationToken());
if (!(segment == null || segment.Results.Count == 0))
{
return(segment.ToList());
}
else
{
return(null);
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
[Table("Collections")] CloudTable collectionsTable, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
TableQuery <CollectionsTableEntity> query = new TableQuery <CollectionsTableEntity>();
TableQuerySegment <CollectionsTableEntity> segment = await collectionsTable.ExecuteQuerySegmentedAsync(query, null);
List <CollectionsTableEntity> tablelist = segment.ToList();
log.LogInformation("Counted: " + tablelist.Count());
// transform the objects returned so they only have the relevant fields
// TODO: error condition
return((ActionResult) new OkObjectResult(segment.Select(Mappings.ToPinItem)));
}
public static async Task <List <DocumentEntity> > DocumentPartitionQuery(TableContinuationToken token, string partitionKey)
{
string tableName = "documents";
if (CheckConnectionString())
{
// Create a table client for interacting with the table service
CloudTableClient cloudTableClient = storageAccount.CreateCloudTableClient();
// Select table to work with
CloudTable cloudTable = cloudTableClient.GetTableReference(tableName);
try
{
// Create a custom table query
// Format: TableQuery.CombineFilters(TableQuery.GenerateFilterCondition(), TableOperators.And, TableQuery.GenerateFilterCondition());
string condition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
TableQuery <DocumentEntity> query = new TableQuery <DocumentEntity>().Where(condition);
// Execute the operation
TableQuerySegment <DocumentEntity> result = await cloudTable.ExecuteQuerySegmentedAsync <DocumentEntity>(query, token);
// Save continuation token
lastToken = result.ContinuationToken;
return(result.ToList());
}
catch (StorageException e)
{
errorLog.Add("DocumentPartitionQuery: " + e.RequestInformation.HttpStatusCode + " " + e.Message);
newErrorFlag = true;
return(null);
}
}
else
{
return(null);
}
}
public async Task <List <T> > ReadAsync <T>(string tableName, string partitionKey = null, string rowKey = null)
where T : ITableEntity, new()
{
CloudTable table = client.GetTableReference(tableName);
await table.CreateIfNotExistsAsync();
TableQuery <T> query;
if (!string.IsNullOrEmpty(partitionKey) && !string.IsNullOrEmpty(rowKey))
{
string q1 = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
string q2 = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey);
query = new TableQuery <T>().Where(TableQuery.CombineFilters(q1, TableOperators.And, q2));
}
else if (!string.IsNullOrEmpty(partitionKey) && string.IsNullOrEmpty(rowKey))
{
query = new TableQuery <T>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
}
else if (string.IsNullOrEmpty(partitionKey) && !string.IsNullOrEmpty(rowKey))
{
query = new TableQuery <T>().Where(
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey));
}
else
{
query = new TableQuery <T>();
}
TableQuerySegment <T> segment = await table.ExecuteQuerySegmentedAsync(query, new TableContinuationToken());
if (!(segment == null || segment.Results.Count == 0))
{
return(segment.ToList());
}
return(null);
}