static async void Run()
{
List<HubReference> hubs = new List<HubReference>();
while (true)
{
Console.WriteLine("Receive messages\n");
string watcherTableConnectionString = ConfigurationManager.ConnectionStrings["WatcherTableStorage"].ToString();
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(watcherTableConnectionString);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("watcher");
TableQuery<WatcherRecordModel> rangeQuery = new TableQuery<WatcherRecordModel>().Take(10000);
IEnumerable<WatcherRecordModel> records = table.ExecuteQuery(rangeQuery);
foreach (WatcherRecordModel record in records)
{
if (record.Timeout < DateTime.Now)
{
TableOperation deleteOperation = TableOperation.Delete(record);
table.Execute(deleteOperation);
}
else if (!IsHubInList(record, hubs))
{
HubReference hub = new HubReference(record.IoTHubConnectionString, record.IotHubEndpoint);
hub.GetMessagesFromHub();
}
}
Thread.Sleep(60 * 1000);
}
}
/// <summary>
/// Get the required number of entries from storage
/// </summary>
/// <param name="partitionKey"></param>
/// <param name="num"></param>
/// <returns></returns>
private IEnumerable<Message> GetEntriesInPartition(string partitionKey, int num)
{
var query = new TableQuery<Message>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey))
.Take(num);
return table.ExecuteQuery(query);
}
//, eResponseFormat format = eResponseFormat.Json)
/// <summary>
/// Let's just do the global reputation an average of local reputation
/// What would be best is to normalize the reputation based on other users in each app
/// </summary>
/// <param name="objectId"></param>
/// <returns></returns>
public object Get(string objectId)
{
HttpContext.Current.Response.Cache.SetNoStore();
var tblTotal = AzureTable.Get("reputationtotals");
TableQuery<ReputationTotal> rangeQuery = new TableQuery<ReputationTotal>().Where(
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, objectId));
// Loop through the results, displaying information about the entity.
var entries = tblTotal.ExecuteQuery(rangeQuery);
if (entries == null || entries.Count() == 0)
return null;
var toltalQuality = 0;
var toltalQuantity = 0;
var toltalTrust = 0;
foreach (ReputationTotal entry in entries) {
toltalQuality += entry.TotalQuality;
toltalQuantity += entry.TotalQuantity;
toltalTrust += entry.TotalTrust;
}
return new {
TotalQuality = toltalQuality / entries.Count(),
TotalQuantity = toltalQuantity / entries.Count(),
TotalTrust = toltalTrust / entries.Count()
};
}
private List<ConnectionEntity> SendMessageTo(String who, String message)
{
//var name = Context.User.Identity.Name;
var name = this.GetConnectionUser();
if (!String.IsNullOrEmpty(name))
{
var table = GetConnectionTable();
// Notice that the partition keys are stored in azure storage as lower case
var query = new TableQuery<ConnectionEntity>()
.Where(TableQuery.GenerateFilterCondition(
"PartitionKey",
QueryComparisons.Equal,
who.ToLowerInvariant()));
var queryResult = table.ExecuteQuery(query).ToList();
if (queryResult.Count == 0)
{
Clients.Caller.showErrorMessage("The user is no longer connected.");
}
else
{
// Load only once the host application connections to display the data there
if(queryResult.Count(o=>o.PartitionKey.Equals(Constants.SignalR_HostApplicationUserName.ToLowerInvariant())) <= 0)
queryResult.AddRange(this.SendMessageTo(Constants.SignalR_HostApplicationUserName, message));
return queryResult;
}
}
return new List<ConnectionEntity>();
}
public List<Good> GetByCategoryId(string categoryId,
bool? isApprover = null)
{
string filter;
if (isApprover.HasValue)
{
filter = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(
"PartitionKey",
QueryComparisons.Equal,
categoryId),
TableOperators.And,
TableQuery.GenerateFilterConditionForBool(
"IsApproved",
QueryComparisons.Equal,
isApprover.Value)
);
}
else
{
filter = TableQuery.GenerateFilterCondition(
"PartitionKey",
QueryComparisons.Equal,
categoryId);
}
var query = new TableQuery<Good>()
.Where(filter);
return Table.ExecuteQuery(query).ToList()
.OrderBy(i => i.Title).ToList();
}
public IEnumerable<IDictionary<string, string>> QueryTable(string tableName, string oDataQuery)
{
if (string.IsNullOrWhiteSpace(tableName)) throw new ArgumentNullException("tableName");
Console.WriteLine(tableName);
var table = cloudTableClient.GetTableReference(tableName);
var query = new TableQuery();
if (!string.IsNullOrWhiteSpace(oDataQuery))
{
query.FilterString = oDataQuery;
}
foreach (var entity in table.ExecuteQuery(query))
{
var dictionary = new Dictionary<string, string>();
dictionary.Add("PartitionKey", entity.PartitionKey);
dictionary.Add("RowKey", entity.RowKey);
dictionary.Add("Timestamp", entity.Timestamp.ToString());
//dictionary.Add("Etag", entity.ETag);
foreach (var property in entity.Properties)
{
dictionary.Add(property.Key, property.Value.StringValue);
}
yield return dictionary;
}
}
/// <summary>
/// Demonstrate a partition scan whereby we are searching for all the entities within a partition. Note this is not as efficient
/// as a range scan - but definitely more efficient than a full table scan. The async API's require the user to implement
/// paging themselves using continuation tokens.
/// </summary>
/// <param name="partitionKey">The partition within which to search</param>
public static async Task<List<AuditModel>> PartitionScanAsync(string partitionKey)
{
// Retrieve the storage account from the connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.AppSettings["StorageConnectionString"]);
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Create the CloudTable object that represents the "people" table.
CloudTable table = tableClient.GetTableReference("audit");
TableQuery<AuditModel> partitionScanQuery = new TableQuery<AuditModel>().Where
(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
var toReturn = new List<AuditModel>();
TableContinuationToken token = null;
// Page through the results
do
{
TableQuerySegment<AuditModel> segment = await table.ExecuteQuerySegmentedAsync(partitionScanQuery, token);
token = segment.ContinuationToken;
foreach (AuditModel entity in segment)
{
toReturn.Add(entity);
}
}
while (token != null);
return toReturn.OrderByDescending(a=> a.Timestamp).ToList();
}
public IEnumerable<SymmetricKey> GetAllKeys()
{
// Create the CloudTable object that represents the "people" table.
var table = tableClient.GetTableReference(keyTableName);
// Create a retrieve operation that takes a customer entity.
var query = new TableQuery<SymmetricKey>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "SymmetricKey"));
try
{
return table.ExecuteQuery(query).ToList();
}
catch (DataServiceQueryException dsq)
{
throw new AzureCryptoException("Failed to load encryption keys from storage", dsq);
}
catch (DataServiceClientException dsce)
{
throw new AzureCryptoException("Failed to load encryption keys from storage", dsce);
}
catch (Exception ex)
{
throw new AzureCryptoException("Could not load encryption keys table", ex);
}
}
public override void Run()
{
Trace.TraceInformation("TweetrPublisher is running");
try
{
TableQuery query = new TableQuery();
TableContinuationToken token = null;
var cancellationToken = _cancellationTokenSource.Token;
while (!cancellationToken.IsCancellationRequested)
{
var segment = Get1000Tweets(query, ref token);
foreach (var tweetTableEntity in segment.Results)
{
var tweetJson = tweetTableEntity.TweetJson;
_tweetQueue.AddMessage(new CloudQueueMessage(tweetJson));
Trace.TraceInformation("Published tweet with id {1} to queue, {0} seconds until next.", 60000 / (_tweetsPerMinute * 1000), tweetTableEntity.Tweet.IdString);
Thread.Sleep(60000 / _tweetsPerMinute);
}
}
//RunAsync(_cancellationTokenSource.Token).Wait();
}
finally
{
_runCompleteEvent.Set();
}
}
private List<LogEntity> GetLogEntities()
{
// Construct the query operation for all customer entities where PartitionKey="Smith".
var query = new TableQuery<LogEntity>();
var entities = _cloudTable.ExecuteQuery(query);
return entities.ToList();
}
/*
public IEnumerable<SensorLog> Get(string device_id)
{
var queryPairs = this.Request.GetQueryNameValuePairs();
string dateLong = queryPairs.FirstOrDefault(q => q.Key == "date").Value;
string storeCS = CloudConfigurationManager.GetSetting("StorageConnectionString");
CloudStorageAccount storageAccound = CloudStorageAccount.Parse(storeCS);
CloudTableClient tableClient = storageAccound.CreateCloudTableClient();
CloudTable sensorLogTable = tableClient.GetTableReference("SensorLog");
TableQuery<SensorLog> query = null;
if (dateLong == null)
{
query = new TableQuery<SensorLog>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, device_id));
} else
{
long dateBinary = long.Parse(dateLong);
DateTime data = DateTime.FromBinary(dateBinary);
query = new TableQuery<SensorLog>().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, device_id),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("UploadTime", QueryComparisons.GreaterThan, data)));
}
var results = sensorLogTable.ExecuteQuery(query);
var sorted = from t in results orderby t.UploadTime select t;
return sorted.Select(ent => (SensorLog)ent).ToList();
}*/
public IEnumerable<SensorLog> Get(string device_id, int len)
{
var queryPairs = this.Request.GetQueryNameValuePairs();
string dateLong = queryPairs.FirstOrDefault(q => q.Key == "date").Value;
string storeCS = CloudConfigurationManager.GetSetting("StorageConnectionString");
CloudStorageAccount storageAccound = CloudStorageAccount.Parse(storeCS);
CloudTableClient tableClient = storageAccound.CreateCloudTableClient();
tableClient.DefaultRequestOptions = new TableRequestOptions()
{
PayloadFormat = TablePayloadFormat.JsonNoMetadata
};
CloudTable sensorLogTable = tableClient.GetTableReference("SensorLog");
TableQuery<SensorLog> query = null;
if (dateLong == null)
{
query = new TableQuery<SensorLog>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, device_id));
}
else
{
long dateBinary = long.Parse(dateLong);
DateTime data = DateTime.FromBinary(dateBinary);
query = new TableQuery<SensorLog>().Where(
TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, device_id),
TableOperators.And,
TableQuery.GenerateFilterConditionForDate("UploadTime", QueryComparisons.GreaterThan, data)));
}
var results = sensorLogTable.ExecuteQuery(query);
var sorted = from t in results orderby t.UploadTime select t;
var list = sorted.Select(ent => (SensorLog)ent).ToList();
return list.GetRange(list.Count - len, len);
}
public Task OpenAsync(PartitionContext context)
{
/*client = new HttpClient();
client.DefaultRequestHeaders.Add("X-ZUMO-APPLICATION", APP_KEY_MOBILE_SERVICES);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
return Task.FromResult<object>(null);*/
var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
var tableClient = storageAccount.CreateCloudTableClient();
sensorLogTable = tableClient.GetTableReference("SensorLog");
//sensorLogTable = tableClient.GetTableReference("SensorLog" + context.Lease.PartitionId);
// 閾値の取得
if (thresholdTempWarning == null)
{
var sensorConfigTable = tableClient.GetTableReference("SensorConfig");
var query = new TableQuery<SensorConfig>();
var configData = sensorConfigTable.ExecuteQuery(query);
foreach (SensorConfig config in configData)
{
if (config.PartitionKey == "TemperatureWarning")
{
thresholdTempWarning = config.Threshold;
System.Console.WriteLine("ThresholdTempWarning: " + thresholdTempWarning);
}
else if (config.PartitionKey == "TemperatureDanger")
{
thresholdTempDanger = config.Threshold;
System.Console.WriteLine("ThresholdTempDanger: " + thresholdTempDanger);
}
}
}
return sensorLogTable.CreateIfNotExistsAsync();
}
public async Task<Response<JsonObject>> GetByIdAsync(string id)
{
if (string.IsNullOrEmpty(id))
throw new ArgumentNullException("id");
var table = await DefineTableAsync(CreateCloudTable).ConfigureAwait(false);
var query =
new TableQuery<DynamicTableEntity>();
query.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "PK"),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, id)));
query.Where(TableQuery.GenerateFilterConditionForBool("sys_deleted", "ne", true));
var items = table.ExecuteQuery(query);
var result = items.ToList();
var json = new JsonObject();
var status = HttpStatusCode.NotFound;
// ReSharper disable UseMethodAny.3
if (result.Count() <= 0) return new Response<JsonObject>(status, json);
// ReSharper restore UseMethodAny.3
json = result.First().ToJsonObject();
status = HttpStatusCode.OK;
return new Response<JsonObject>(status, json);
}
private TableQuery<LogEntity> MapQuery(AzureNLogQueryDefinition originalQuery)
{
var query = new TableQuery<LogEntity>();
var filters = new[]
{
this.GetPartitionKeyFilter(originalQuery), this.GetMinDateFilter(originalQuery),
this.GetMaxDateFilter(originalQuery), this.GetLevelFilter(originalQuery)
}
.Where(f => !string.IsNullOrWhiteSpace(f))
.ToArray();
if (!filters.Any())
{
return query;
}
var querySt = filters[0];
for (var i = 1; i < filters.Length; i++)
{
querySt = TableQuery.CombineFilters(querySt, TableOperators.And, filters[i]);
}
return query.Where(querySt);
}
public async Task BuildIndexes()
{
TableQuery<TableUser> query = new TableQuery<TableUser>();
TableQuerySegment<TableUser> querySegment = null;
List<Task> insertOperation = new List<Task>();
while (querySegment == null || querySegment.ContinuationToken != null)
{
querySegment = await _userTable.ExecuteQuerySegmentedAsync(query, querySegment != null ? querySegment.ContinuationToken : null);
foreach (TableUser tableUser in querySegment.Results)
{
TableUserIdIndex indexItem = new TableUserIdIndex(tableUser.UserName, tableUser.Id);
insertOperation.Add(_userIndexTable.ExecuteAsync(TableOperation.InsertOrReplace(indexItem)));
if (insertOperation.Count > 100)
{
await Task.WhenAll(insertOperation);
insertOperation.Clear();
}
}
if (insertOperation.Count > 0)
{
await Task.WhenAll(insertOperation);
insertOperation.Clear();
}
}
}
public List<ICatalogJob> GetAllCatalogJob(string organization)
{
string tableName = NameHelper.GetCatalogJobTableName(organization);
tableName = TableDataAccess.ValidateTableName(tableName);
TableDataAccess tableDataAccess = new TableDataAccess(TableClient);
CloudTable table = tableDataAccess.GetTable(tableName);
if (table == null)
return null;
TableQuery<CatalogEntity> query = new TableQuery<CatalogEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, organization));
query.TakeCount = 100;
TableRequestOptions a = new TableRequestOptions();
OperationContext c = new OperationContext();
var queryResult = table.ExecuteQuery(query);
List<ICatalogJob> result = new List<ICatalogJob>(queryResult.Count());
foreach (CatalogEntity entity in queryResult)
{
CatalogEntity.SetOtherByPartitionRowKeys(entity);
result.Add(entity);
}
return result;
}
internal ISet<string> GetAllItemsFromParttion(string partitionKey)
{
var returnSet = new HashSet<string>();
try
{
var tableQuery =
new TableQuery<ToBeIndexedEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey",
QueryComparisons.Equal,
partitionKey));
var exec = _table.ExecuteQuery(tableQuery);
foreach (var toBeIndexedEntity in exec)
{
returnSet.Add(toBeIndexedEntity.EntityId);
}
}
catch (Exception ex)
{
Trace.TraceError("Error in getting all entities for parition {0}, exception {1}", partitionKey, ex);
}
return returnSet;
}
public TableBinding(ScriptHostConfiguration config, TableBindingMetadata metadata, FileAccess access)
: base(config, metadata, access)
{
if (string.IsNullOrEmpty(metadata.TableName))
{
throw new ArgumentException("The table name cannot be null or empty.");
}
TableName = metadata.TableName;
PartitionKey = metadata.PartitionKey;
if (!string.IsNullOrEmpty(PartitionKey))
{
_partitionKeyBindingTemplate = BindingTemplate.FromString(PartitionKey);
}
RowKey = metadata.RowKey;
if (!string.IsNullOrEmpty(RowKey))
{
_rowKeyBindingTemplate = BindingTemplate.FromString(RowKey);
}
_tableQuery = new TableQuery
{
TakeCount = metadata.Take ?? 50,
FilterString = metadata.Filter
};
}
//
// GET: /MailingList/
public async Task<ActionResult> Index()
{
List<MailingList> lists = new List<MailingList>();
try
{
// This code gets all rows; for a production app implement paging
// to avoid executing an unbounded query that might return too many rows.
var query = new TableQuery<MailingList>().Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, "mailinglist"));
TableContinuationToken token = null;
OperationContext ctx = new OperationContext();
TableQuerySegment<MailingList> currentSegment = null;
while (currentSegment == null || currentSegment.ContinuationToken != null)
{
currentSegment = await mailingListTable.ExecuteQuerySegmentedAsync(query, token, webUIRetryPolicy, ctx);
lists.AddRange(currentSegment.Results);
token = currentSegment.ContinuationToken;
}
}
catch (StorageException se)
{
ViewBag.errorMessage = "Timeout error, try again. ";
Trace.TraceError(se.Message);
return View("Error");
}
return View(lists);
}
public long ClearTable()
{
long deletionCount = 0;
// Construct the query operation for all customer entities where PartitionKey="Smith".
var list = new List<string>();
list.Add("PartitionKey");
list.Add("RowKey");
TableQuery<SensorValueEntity> query = new TableQuery<SensorValueEntity>().Select(list).Take(100);
var results = table.ExecuteQuery(query);
if (results.Count() < 1)
return deletionCount;
foreach(var resultGroup in results.GroupBy(a => a.PartitionKey))
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var result in resultGroup)
{
batchOperation.Delete(result);
deletionCount++;
}
table.ExecuteBatch(batchOperation);
}
return deletionCount;
}
public List<Reply> GetReplyNotif(string userid)
{
TableQuery<ReplyNotificationEntifity> query = new TableQuery<ReplyNotificationEntifity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, userid));
List<Reply> replies = new List<Reply>();
TableBatchOperation batchOperation = new TableBatchOperation();
int count = 0;
// Print the fields for each customer.
foreach (ReplyNotificationEntifity entity in _replyNotification.ExecuteQuery(query))
{
replies.Add(JsonConvert.DeserializeObject<Reply>(entity.Content));
batchOperation.Add(TableOperation.Delete(entity));
count++;
if((count % 100) == 0){
_replyNotification.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
count = 0;
}
}
if (count > 0)
{
_replyNotification.ExecuteBatch(batchOperation);
}
return replies;
}
public ActionResult Details(string id)
{
var textQuery = new TableQuery<TextEntity>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, id));
var textEntity = this.textsTable
.ExecuteQuery(textQuery)
.Select(TextDetailsViewModel.FromEntity)
.FirstOrDefault();
if (textEntity == null)
{
throw new HttpException(404, "There is no such text.");
}
if (this.User.IsAdmin())
{
var similarLinksQuery = new TableQuery<SimilarLinkEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, textEntity.TextId));
var similarLinks = this.similarLinksTable
.ExecuteQuery(similarLinksQuery)
.Select(SimilarLinkViewModel.FromEntity);
textEntity.SimilarLinks = similarLinks.ToList();
}
textEntity.Text = this.blobContainer.GetBlockBlobReference(textEntity.TextId).DownloadText();
return this.View(textEntity);
}
public ActionResult Index(string id, string listName)
{
if (string.IsNullOrEmpty(id) == true || string.IsNullOrEmpty(listName))
{
ViewBag.errorMessage = "Empty subscriber ID or list name.";
return View("Error");
}
string filter = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, listName),
TableOperators.And,
TableQuery.GenerateFilterCondition("SubscriberGUID", QueryComparisons.Equal, id));
var query = new TableQuery<Subscriber>().Where(filter);
var subscriber = mailingListTable.ExecuteQuery(query).ToList().Single();
if (subscriber == null)
{
ViewBag.Message = "You are already unsubscribed";
return View("Message");
}
var unsubscribeVM = new UnsubscribeVM();
unsubscribeVM.EmailAddress = MaskEmail(subscriber.EmailAddress);
unsubscribeVM.ListDescription = FindRow(subscriber.ListName, "mailinglist").Description;
unsubscribeVM.SubscriberGUID = id;
unsubscribeVM.Confirmed = null;
return View(unsubscribeVM);
}
public IEnumerable<Author> GetAuthors(string firstname, string lastname)
{
CloudTable authorTable = GetTableReference(tableName);
if (authorTable == null) return new List<Author>();
TableQuery<Author> query = default(TableQuery<Author>);
if (!string.IsNullOrEmpty(firstname) && !string.IsNullOrEmpty(lastname))
{
string lastnameFilter = TableQuery.GenerateFilterCondition("Lastname", QueryComparisons.Equal, lastname);
string firstnameFilter = TableQuery.GenerateFilterCondition("Firstname", QueryComparisons.Equal, firstname);
string finalFilter = TableQuery.CombineFilters(lastnameFilter, TableOperators.And, firstnameFilter);
query = new TableQuery<Author>().Where(finalFilter);
}
else if (!string.IsNullOrEmpty(firstname))
{
query = new TableQuery<Author>()
.Where(TableQuery.GenerateFilterCondition("Firstname", QueryComparisons.Equal, firstname));
}
else if (!string.IsNullOrEmpty(lastname))
{
query = new TableQuery<Author>()
.Where(TableQuery.GenerateFilterCondition("Lastname", QueryComparisons.Equal, lastname));
}
else
{
query = new TableQuery<Author>();
}
return authorTable.ExecuteQuery<Author>(query);
}
public Services(SmsMessage smsMessage)
{
if (smsMessage != null)
{
CloudTable table = cloudTable("games");
table.CreateIfNotExists();
TableQuery<Game> query = new TableQuery<Game>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, smsMessage.From),
"and",
TableQuery.GenerateFilterCondition("Status", QueryComparisons.Equal, "Live"))
);
IEnumerable<Game> games = table.ExecuteQuery(query);
if (games.Count() > 0)
{
Game = games.First();
table = cloudTable("characters");
TableQuery<Character> characterQuery = new TableQuery<Character>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, Game.Character));
IEnumerable<Character> characters = table.ExecuteQuery(characterQuery);
if (characters.Count() > 0)
Character = characters.First();
}
}
}
//
// GET: /Subscription/
//
// Note: This way of handling may not scale and may need to use continuation tokens later
//
public ActionResult Index()
{
TableRequestOptions reqOptions = new TableRequestOptions()
{
MaximumExecutionTime = TimeSpan.FromSeconds(10),
RetryPolicy = new LinearRetry(TimeSpan.FromSeconds(3), 3)
};
List<Subscription> subscribers;
try
{
var query = new TableQuery<Subscription>().Select(new string[] {
"PartitionKey",
"RowKey",
"Description",
"Verified"
});
subscribers = subscribersTable.ExecuteQuery(query, reqOptions).ToList();
}
catch (StorageException se)
{
ViewBag.errorMessage = "Timeout error, try again.";
Trace.TraceError(se.Message);
return View("Error: " + se.Message);
}
return View(subscribers);
}
public FixtureForUpdatingBatchsOfRecords()
{
// ARRANGE
TableClient = GetTableClient();
Table = CreateTable();
var tasks = Enumerable.Range(0, 600).Select(i =>
{
var op = TableOperation.Insert(new TestingEntity("partitionKey", Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
return Table.ExecuteAsync(op);
});
Task.WhenAll(tasks).Wait();
var tableQuery = new TableQuery<TestingEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "partitionKey"));
var subject = new TsSet<TestingEntity>(new TsTable<TestingEntity>(Table));
// ACT
Result = subject.BatchUpdateAsync(
tableQuery,
entities =>
{
entities.ForEach(e => e.MyProperty = "Test");
}).Result;
}
public ActionResult DeleteConfirmed(string partitionKey)
{
// Delete all rows for this mailing list, that is,
// Subscriber rows as well as MailingList rows.
// Therefore, no need to specify row key.
var query = new TableQuery<MailingList>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey));
var listRows = mailingListTable.ExecuteQuery(query).ToList();
var batchOperation = new TableBatchOperation();
int itemsInBatch = 0;
foreach (MailingList listRow in listRows)
{
batchOperation.Delete(listRow);
itemsInBatch++;
if (itemsInBatch == 100)
{
mailingListTable.ExecuteBatch(batchOperation);
itemsInBatch = 0;
batchOperation = new TableBatchOperation();
}
}
if (itemsInBatch > 0)
{
mailingListTable.ExecuteBatch(batchOperation);
}
return RedirectToAction("Index");
}
public async Task RunAsync(CancellationToken cancellationToken)
{
var sw = Stopwatch.StartNew();
var min = _fromDate.ToUniversalTime().Ticks;
var max = _toDate.ToUniversalTime().Ticks;
var table = _tableClient.GetTableReference("WADPerformanceCountersTable");
var query = new TableQuery<WADPerformanceCountersTable>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.GreaterThanOrEqual, min.ToString("d19")),
TableOperators.And,
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.LessThan, max.ToString("d19"))));
var result = new List<WADPerformanceCountersTable>();
TableContinuationToken token = null;
do
{
var segment = await table.ExecuteQuerySegmentedAsync(query, token, null, null, cancellationToken);
token = segment.ContinuationToken;
result.AddRange(segment.Results);
// Console.Write($"{segment.Results.Count}.");
} while (token != null);
Console.WriteLine();
sw.Stop();
Console.WriteLine("Count:{0}, Min: {1}, Max: {2}, Elapsed: {3:F2} sec",
result.Count, result.Min(e => e.PartitionKey), result.Max(e => e.PartitionKey), (sw.ElapsedMilliseconds / 1000.0));
}
private TableQuery <DynamicTableEntity> GenerateListTablesQuery(string prefix, int?maxResults)
{
TableQuery <DynamicTableEntity> query = new TableQuery <DynamicTableEntity>();
if (!string.IsNullOrEmpty(prefix))
{
// Append Max char to end '{' is 1 + 'z' in AsciiTable
string uppperBound = prefix + '{';
query = query.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition(TableConstants.TableName, QueryComparisons.GreaterThanOrEqual, prefix),
TableOperators.And,
TableQuery.GenerateFilterCondition(TableConstants.TableName, QueryComparisons.LessThan, uppperBound)));
}
if (maxResults.HasValue)
{
query = query.Take(maxResults.Value);
}
return(query);
}
public void TableIngressEgressQuery()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableBatchOperation batch = new TableBatchOperation();
for (int m = 0; m < 100; m++)
{
// Insert Entity
DynamicTableEntity insertEntity = new DynamicTableEntity("insert test", m.ToString());
insertEntity.Properties.Add("prop" + m.ToString(), new EntityProperty(new byte[30 * 1024]));
batch.Insert(insertEntity);
}
currentTable.ExecuteBatch(batch);
TableQuery query = new TableQuery().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "insert test"));
// APM
TestHelper.ValidateIngressEgress(Selectors.IfUrlContains(currentTable.Uri.ToString()), () =>
{
OperationContext opContext = new OperationContext();
currentTable.EndExecuteQuerySegmented(currentTable.BeginExecuteQuerySegmented(query, null, new TableRequestOptions()
{
RetryPolicy = new RetryPolicies.NoRetry()
}, opContext, null, null));
return(opContext.LastResult);
});
// SYNC
TestHelper.ValidateIngressEgress(Selectors.IfUrlContains(currentTable.Uri.ToString()), () =>
{
OperationContext opContext = new OperationContext();
currentTable.ExecuteQuerySegmented(query, null, new TableRequestOptions()
{
RetryPolicy = new RetryPolicies.NoRetry()
}, opContext);
return(opContext.LastResult);
});
}
public void TableQueryableWhere()
{
OperationContext opContext = new OperationContext();
TableQuery <DynamicTableEntity> res = (from ent in currentTable.CreateQuery <DynamicTableEntity>()
where ent.PartitionKey == "tables_batch_1" &&
ent.RowKey.CompareTo("0050") >= 0
select ent).WithContext(opContext);
int count = 0;
foreach (DynamicTableEntity ent in res)
{
Assert.AreEqual(ent.Properties["test"].StringValue, "test");
Assert.AreEqual(ent.PartitionKey, "tables_batch_1");
Assert.AreEqual(ent.RowKey, string.Format("{0:0000}", count + 50));
count++;
}
Assert.AreEqual(count, 50);
}
internal TElement ReturnSingleton <TElement>(Expression expression)
{
IQueryable <TElement> query = new TableQuery <TElement>(expression, this);
MethodCallExpression mce = expression as MethodCallExpression;
SequenceMethod sequenceMethod;
if (ReflectionUtil.TryIdentifySequenceMethod(mce.Method, out sequenceMethod))
{
switch (sequenceMethod)
{
case SequenceMethod.Single:
return(query.AsEnumerable().Single());
case SequenceMethod.SingleOrDefault:
return(query.AsEnumerable().SingleOrDefault());
case SequenceMethod.First:
return(query.AsEnumerable().First());
case SequenceMethod.FirstOrDefault:
return(query.AsEnumerable().FirstOrDefault());
/*
* if !ASTORIA_LIGHT && !WINDOWS_RT
* case SequenceMethod.LongCount:
* case SequenceMethod.Count:
* return (TElement)Convert.ChangeType(((TableQuery<TElement>)query).GetQuerySetCount(this.Context), typeof(TElement), System.Globalization.CultureInfo.InvariantCulture.NumberFormat);
* //#endif
*/
}
}
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, SR.ALinqMethodNotSupported, mce.Method.Name));
}
public void TableQueryWithRetryAPM()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableBatchOperation batch = new TableBatchOperation();
for (int m = 0; m < 1500; m++)
{
// Insert Entity
DynamicTableEntity insertEntity = new DynamicTableEntity("insert test", m.ToString());
insertEntity.Properties.Add("prop" + m.ToString(), new EntityProperty(new byte[1 * 1024]));
batch.Insert(insertEntity);
if ((m + 1) % 100 == 0)
{
currentTable.ExecuteBatch(batch);
batch = new TableBatchOperation();
}
}
TableQuery query = new TableQuery().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "insert test"));
TestHelper.ExecuteAPMMethodWithRetry(
2, // 1 failure, one success
new[] {
//Insert upstream network delay to prevent upload to server @ 1000ms / kb
PerformanceBehaviors.InsertDownstreamNetworkDelay(10000,
XStoreSelectors.TableTraffic().IfHostNameContains(tableClient.Credentials.AccountName).Alternating(true)),
// After 100 ms return throttle message
DelayedActionBehaviors.ExecuteAfter(Actions.ThrottleTableRequest,
100,
XStoreSelectors.TableTraffic().IfHostNameContains(tableClient.Credentials.AccountName).Alternating(true))
},
(options, opContext, callback, state) => currentTable.BeginExecuteQuerySegmented(query, null, (TableRequestOptions)options, opContext, callback, state),
(res) => currentTable.EndExecuteQuerySegmented(res));
}
internal IEnumerable <DynamicTableEntity> ExecuteQuery(TableQuery query)
{
return(this.ExecuteQuery(query, null /* RequestOptions */, null /* OperationContext */));
}
/// <summary>
/// Executes a query in segmented mode with the specified <see cref="TableContinuationToken"/> continuation token, <see cref="TableRequestOptions"/>, and <see cref="OperationContext"/>.
/// </summary>
/// <param name="query">A <see cref="TableQuery"/> representing the query to execute.</param>
/// <param name="token">A <see cref="ResultContinuation"/> object representing a continuation token from the server when the operation returns a partial result.</param>
/// <param name="requestOptions">A <see cref="TableRequestOptions"/> object that specifies execution options, such as retry policy and timeout settings, for the operation.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A <see cref="TableQuerySegment"/> object containing the results of executing the query.</returns>
public IAsyncOperation <TableQuerySegment> ExecuteQuerySegmentedAsync(TableQuery query, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNull("query", query);
return(query.ExecuteQuerySegmentedAsync(token, this.ServiceClient, this.Name, requestOptions, operationContext));
}
/// <summary>
/// Executes a query in segmented mode with the specified <see cref="TableContinuationToken"/> continuation token.
/// </summary>
/// <param name="query">A <see cref="TableQuery"/> representing the query to execute.</param>
/// <param name="token">A <see cref="ResultContinuation"/> object representing a continuation token from the server when the operation returns a partial result.</param>
/// <returns>A <see cref="TableQuerySegment"/> object containing the results of executing the query.</returns>
public IAsyncOperation <TableQuerySegment> ExecuteQuerySegmentedAsync(TableQuery query, TableContinuationToken token)
{
return(this.ExecuteQuerySegmentedAsync(query, token, null /* RequestOptions */, null /* OperationContext */));
}
private async Task DoTableGenericQueryOnSupportedTypesAsync(TablePayloadFormat format)
{
CloudTableClient client = GenerateCloudTableClient();
client.DefaultRequestOptions.PayloadFormat = format;
CloudTable table = client.GetTableReference(GenerateRandomTableName());
await table.CreateAsync();
try
{
// Setup
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
ComplexEntity middleRef = null;
for (int m = 0; m < 100; m++)
{
ComplexEntity complexEntity = new ComplexEntity(pk, string.Format("{0:0000}", m));
complexEntity.String = string.Format("{0:0000}", m);
complexEntity.Binary = new byte[] { 0x01, 0x02, (byte)m };
complexEntity.BinaryPrimitive = new byte[] { 0x01, 0x02, (byte)m };
complexEntity.Bool = m % 2 == 0 ? true : false;
complexEntity.BoolPrimitive = m % 2 == 0 ? true : false;
complexEntity.Double = m + ((double)m / 100);
complexEntity.DoublePrimitive = m + ((double)m / 100);
complexEntity.Int32 = m;
complexEntity.IntegerPrimitive = m;
complexEntity.Int64 = (long)int.MaxValue + m;
complexEntity.LongPrimitive = (long)int.MaxValue + m;
complexEntity.Guid = Guid.NewGuid();
batch.Insert(complexEntity);
if (m == 50)
{
middleRef = complexEntity;
}
// Add delay to make times unique
await Task.Delay(100);
}
await table.ExecuteBatchAsync(batch);
// 1. Filter on String
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterCondition("String", QueryComparisons.GreaterThanOrEqual, "0050"), 50);
// 2. Filter on Guid
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForGuid("Guid", QueryComparisons.Equal, middleRef.Guid), 1);
// 3. Filter on Long
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForLong("Int64", QueryComparisons.GreaterThanOrEqual,
middleRef.LongPrimitive), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForLong("LongPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.LongPrimitive), 50);
// 4. Filter on Double
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.GreaterThanOrEqual,
middleRef.Double), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForDouble("DoublePrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.DoublePrimitive), 50);
// 5. Filter on Integer
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForInt("Int32", QueryComparisons.GreaterThanOrEqual,
middleRef.Int32), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForInt("IntegerPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.IntegerPrimitive), 50);
// 6. Filter on Date
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForDate("DateTimeOffset", QueryComparisons.GreaterThanOrEqual,
middleRef.DateTimeOffset), 50);
// 7. Filter on Boolean
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, middleRef.Bool), 50);
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBool("BoolPrimitive", QueryComparisons.Equal, middleRef.BoolPrimitive),
50);
// 8. Filter on Binary
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.Equal, middleRef.Binary), 1);
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.Equal,
middleRef.BinaryPrimitive), 1);
// 9. Filter on Binary GTE
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
middleRef.Binary), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.BinaryPrimitive), 50);
// 10. Complex Filter on Binary GTE
ExecuteQueryAndAssertResults(table, TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
middleRef.PartitionKey),
TableOperators.And,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
middleRef.Binary)), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.BinaryPrimitive), 50);
}
finally
{
table.DeleteIfExistsAsync().AsTask().Wait();
}
}
public async Task TableQueryEmptyValueAsync()
{
CloudTableClient client = GenerateCloudTableClient();
CloudTable table = client.GetTableReference(GenerateRandomTableName());
await table.CreateAsync();
// Setup
string pk = Guid.NewGuid().ToString();
DynamicTableEntity dynEnt = new DynamicTableEntity(pk, "rowkey");
dynEnt.Properties.Add("A", new EntityProperty(string.Empty));
await table.ExecuteAsync(TableOperation.Insert(dynEnt));
// 1. Filter on String
List <DynamicTableEntity> results = (await table.ExecuteQuerySegmentedAsync(new TableQuery().Where(TableQuery.GenerateFilterCondition("A", QueryComparisons.Equal, string.Empty)), null)).ToList();
Assert.AreEqual(1, results.Count);
List <BaseEntity> pocoresults = (await table.ExecuteQuerySegmentedAsync(new TableQuery <BaseEntity>().Where(TableQuery.GenerateFilterCondition("A", QueryComparisons.Equal, string.Empty)), null)).ToList();
Assert.AreEqual(1, pocoresults.Count);
}
public async Task TableRegionalQueryOnSupportedTypesAsync()
{
#if ASPNET_K
//CultureInfo currentCulture = CultureInfo.CurrentCulture;
//CultureInfo.CurrentCulture = new CultureInfo("tr");
#else
string currentPrimaryLanguage = ApplicationLanguages.PrimaryLanguageOverride;
ApplicationLanguages.PrimaryLanguageOverride = "tr";
#endif
CloudTableClient client = GenerateCloudTableClient();
CloudTable table = client.GetTableReference(GenerateRandomTableName());
await table.CreateAsync();
try
{
// Setup
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
DynamicTableEntity middleRef = null;
for (int m = 0; m < 100; m++)
{
ComplexEntity complexEntity = new ComplexEntity();
complexEntity.String = string.Format("{0:0000}", m);
complexEntity.Binary = new byte[] { 0x01, 0x02, (byte)m };
complexEntity.BinaryPrimitive = new byte[] { 0x01, 0x02, (byte)m };
complexEntity.Bool = m % 2 == 0 ? true : false;
complexEntity.BoolPrimitive = m % 2 == 0 ? true : false;
complexEntity.Double = m + ((double)m / 100);
complexEntity.DoublePrimitive = m + ((double)m / 100);
complexEntity.Int32 = m;
complexEntity.IntegerPrimitive = m;
complexEntity.Int64 = (long)int.MaxValue + m;
complexEntity.LongPrimitive = (long)int.MaxValue + m;
complexEntity.Guid = Guid.NewGuid();
DynamicTableEntity dynEnt = new DynamicTableEntity(pk, string.Format("{0:0000}", m));
dynEnt.Properties = complexEntity.WriteEntity(null);
batch.Insert(dynEnt);
if (m == 50)
{
middleRef = dynEnt;
}
// Add delay to make times unique
await Task.Delay(100);
}
await table.ExecuteBatchAsync(batch);
// 1. Filter on String
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterCondition("String", QueryComparisons.GreaterThanOrEqual, "0050"), 50);
// 2. Filter on Guid
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForGuid("Guid", QueryComparisons.Equal, middleRef.Properties["Guid"].GuidValue.Value), 1);
// 3. Filter on Long
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForLong("Int64", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["LongPrimitive"].Int64Value.Value), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForLong("LongPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.Properties["LongPrimitive"].Int64Value.Value), 50);
// 4. Filter on Double
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForDouble("Double", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["Double"].DoubleValue.Value), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForDouble("DoublePrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.Properties["DoublePrimitive"].DoubleValue.Value), 50);
// 5. Filter on Integer
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForInt("Int32", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["Int32"].Int32Value.Value), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForInt("IntegerPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.Properties["IntegerPrimitive"].Int32Value.Value), 50);
// 6. Filter on Date
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForDate("DateTimeOffset", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["DateTimeOffset"].DateTimeOffsetValue.Value), 50);
// 7. Filter on Boolean
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBool("Bool", QueryComparisons.Equal, middleRef.Properties["Bool"].BooleanValue.Value), 50);
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBool("BoolPrimitive", QueryComparisons.Equal, middleRef.Properties["BoolPrimitive"].BooleanValue.Value),
50);
// 8. Filter on Binary
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.Equal, middleRef.Properties["Binary"].BinaryValue), 1);
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive", QueryComparisons.Equal,
middleRef.Properties["BinaryPrimitive"].BinaryValue), 1);
// 9. Filter on Binary GTE
ExecuteQueryAndAssertResults(table,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["Binary"].BinaryValue), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.Properties["BinaryPrimitive"].BinaryValue), 50);
// 10. Complex Filter on Binary GTE
ExecuteQueryAndAssertResults(table, TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
middleRef.PartitionKey),
TableOperators.And,
TableQuery.GenerateFilterConditionForBinary("Binary", QueryComparisons.GreaterThanOrEqual,
middleRef.Properties["Binary"].BinaryValue)), 50);
ExecuteQueryAndAssertResults(table, TableQuery.GenerateFilterConditionForBinary("BinaryPrimitive",
QueryComparisons.GreaterThanOrEqual, middleRef.Properties["BinaryPrimitive"].BinaryValue), 50);
}
finally
{
#if ASPNET_K
//CultureInfo.CurrentCulture = currentCulture;
#else
ApplicationLanguages.PrimaryLanguageOverride = currentPrimaryLanguage;
#endif
table.DeleteIfExistsAsync().AsTask().Wait();
}
}
private static List <TResult> ExecuteQueryWithResolver <TResult>(CloudTable table, TableQuery query, EntityResolver <TResult> resolver)
{
List <TResult> retList = new List <TResult>();
TableQuerySegment <TResult> currSeg = null;
while (currSeg == null || currSeg.ContinuationToken != null)
{
Task <TableQuerySegment <TResult> > task = Task.Run(() => table.ExecuteQuerySegmentedAsync(query, resolver, currSeg != null ? currSeg.ContinuationToken : null).AsTask());
task.Wait();
currSeg = task.Result;
retList.AddRange(currSeg.Results);
}
return(retList);
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, string tableName, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions) where T : ITableEntity, new()
{
UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties);
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, tableName);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri);
requestOptions.ApplyToStorageCommand(queryCmd);
queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token);
queryCmd.RetrieveResponseStream = true;
queryCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib;
queryCmd.Builder = builder;
queryCmd.BuildRequest = (cmd, uri, queryBuilder, cnt, serverTimeout, ctx) => TableOperationHttpRequestMessageFactory.BuildRequestForTableQuery(uri, builder, serverTimeout, cnt, ctx, requestOptions.PayloadFormat.Value, client.GetCanonicalizer(), client.Credentials);
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp.StatusCode, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = async(cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName);
if (resSeg.ContinuationToken != null)
{
resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
}
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions)
{
UriQueryBuilder builder = query.GenerateQueryBuilder();
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, table.Name);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri);
requestOptions.ApplyToStorageCommand(queryCmd);
queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.Builder = builder;
queryCmd.ParseError = StorageExtendedErrorInformation.ReadFromStreamUsingODataLib;
queryCmd.BuildRequestDelegate = (uri, queryBuilder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableQuery(uri, queryBuilder, timeout, useVersionHeader, ctx, requestOptions.PayloadFormat.Value);
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE, T>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx, client.AccountName);
if (resSeg.ContinuationToken != null)
{
resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
}
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
public static TableQuery <TElement> StartWith <TElement>(this TableQuery <TElement> query, string columnName, string value)
where TElement : ITableEntity, new()
{
return(query.StartWith(columnName, value, TableOperators.And));
}
private static RESTCommand <TableQuerySegment <RESULT_TYPE> > QueryImpl <T, RESULT_TYPE>(TableQuery <T> query, TableContinuationToken token, CloudTableClient client, CloudTable table, EntityResolver <RESULT_TYPE> resolver, TableRequestOptions requestOptions)
{
requestOptions.AssertPolicyIfRequired();
// If encryption policy is set, then add the encryption metadata column to Select columns in order to be able to decrypt properties.
if (requestOptions.EncryptionPolicy != null && query.SelectColumns != null && query.SelectColumns.Count() > 0)
{
query.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionKeyDetails);
query.SelectColumns.Add(Constants.EncryptionConstants.TableEncryptionPropertyDetails);
}
UriQueryBuilder builder = query.GenerateQueryBuilder(requestOptions.ProjectSystemProperties);
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
StorageUri tempUri = NavigationHelper.AppendPathToUri(client.StorageUri, table.Name);
RESTCommand <TableQuerySegment <RESULT_TYPE> > queryCmd = new RESTCommand <TableQuerySegment <RESULT_TYPE> >(client.Credentials, tempUri);
requestOptions.ApplyToStorageCommand(queryCmd);
queryCmd.CommandLocationMode = CommonUtility.GetListingLocationMode(token);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.Builder = builder;
queryCmd.ParseError = ODataErrorHelper.ReadFromStreamUsingODataLib;
queryCmd.BuildRequestDelegate = (uri, queryBuilder, timeout, useVersionHeader, ctx) => TableOperationHttpWebRequestFactory.BuildRequestForTableQuery(uri, queryBuilder, timeout, useVersionHeader, ctx, requestOptions.PayloadFormat.Value);
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex);
queryCmd.PostProcessResponse = (cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <RESULT_TYPE, T>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx);
if (resSeg.ContinuationToken != null)
{
resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
}
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
queryCmd.PostProcessResponseAsync = async(cmd, resp, ctx) =>
{
ResultSegment <RESULT_TYPE> resSeg = await TableOperationHttpResponseParsers.TableQueryPostProcessGenericAsync <RESULT_TYPE, T>(cmd.ResponseStream, resolver.Invoke, resp, requestOptions, ctx);
if (resSeg.ContinuationToken != null)
{
resSeg.ContinuationToken.TargetLocation = cmd.CurrentResult.TargetLocation;
}
return(new TableQuerySegment <RESULT_TYPE>(resSeg));
};
return(queryCmd);
}
internal IEnumerable <DynamicTableEntity> ExecuteQuery(TableQuery query, TableRequestOptions requestOptions, OperationContext operationContext)
{
CommonUtility.AssertNotNull("query", query);
return(query.Execute(this.ServiceClient, this.Name, requestOptions, operationContext));
}
private static RESTCommand <TableQuerySegment <DynamicTableEntity> > QueryImpl(TableQuery query, TableContinuationToken token, CloudTableClient client, string tableName, TableRequestOptions requestOptions)
{
Uri tempUri = NavigationHelper.AppendPathToUri(client.BaseUri, tableName);
UriQueryBuilder builder = query.GenerateQueryBuilder();
if (token != null)
{
token.ApplyToUriQueryBuilder(builder);
}
Uri reqUri = builder.AddToUri(tempUri);
RESTCommand <TableQuerySegment <DynamicTableEntity> > queryCmd = new RESTCommand <TableQuerySegment <DynamicTableEntity> >(client.Credentials, reqUri);
requestOptions.ApplyToStorageCommand(queryCmd);
queryCmd.RetrieveResponseStream = true;
queryCmd.SignRequest = client.AuthenticationHandler.SignRequest;
queryCmd.BuildRequestDelegate = TableOperationHttpWebRequestFactory.BuildRequestForTableQuery;
queryCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.OK, resp != null ? resp.StatusCode : HttpStatusCode.Unused, null /* retVal */, cmd, ex, ctx);
queryCmd.PostProcessResponse = (cmd, resp, ex, ctx) =>
{
ResultSegment <DynamicTableEntity> resSeg = TableOperationHttpResponseParsers.TableQueryPostProcessGeneric <DynamicTableEntity>(cmd.ResponseStream, EntityUtilities.ResolveDynamicEntity, resp, ex, ctx);
return(new TableQuerySegment <DynamicTableEntity>(resSeg));
};
return(queryCmd);
}
public void TableQueryableProjection()
{
OperationContext opContext = new OperationContext();
var baseQuery = currentTable.CreateQuery <POCOEntity>().WithContext(opContext);
var pocoRes = (from ent in baseQuery
select new ProjectedPOCO()
{
PartitionKey = ent.PartitionKey,
RowKey = ent.RowKey,
Timestamp = ent.Timestamp,
a = ent.a,
c = ent.c
});
int count = 0;
foreach (ProjectedPOCO ent in pocoRes)
{
Assert.IsNotNull(ent.PartitionKey);
Assert.IsNotNull(ent.RowKey);
Assert.IsNotNull(ent.Timestamp);
Assert.AreEqual(ent.a, "a");
Assert.IsNull(ent.b);
Assert.AreEqual(ent.c, "c");
Assert.IsNull(ent.d);
count++;
}
// Project a single property via Select
var stringRes = (from ent in baseQuery
select ent.b).ToList();
Assert.AreEqual(stringRes.Count, count);
// TableQuery.Project no resolver
IQueryable <POCOEntity> projectionResult = (from ent in baseQuery
select TableQuery.Project(ent, "a", "b"));
count = 0;
foreach (POCOEntity ent in projectionResult)
{
Assert.IsNotNull(ent.PartitionKey);
Assert.IsNotNull(ent.RowKey);
Assert.IsNotNull(ent.Timestamp);
Assert.AreEqual(ent.a, "a");
Assert.AreEqual(ent.b, "b");
Assert.IsNull(ent.c);
Assert.IsNull(ent.test);
count++;
}
Assert.AreEqual(stringRes.Count, count);
// TableQuery.Project no resolver
IQueryable <string> resolverRes = (from ent in baseQuery
select TableQuery.Project(ent, "a", "b")).Resolve((pk, rk, ts, props, etag) => props["a"].StringValue);
count = 0;
foreach (string s in resolverRes)
{
Assert.AreEqual(s, "a");
count++;
}
Assert.AreEqual(stringRes.Count, count);
}
private void DoEscapeTest(string data, bool useBatch, bool includeKey)
{
DynamicTableEntity ent = new DynamicTableEntity(includeKey ? "temp" + data : "temp", Guid.NewGuid().ToString());
ent.Properties.Add("foo", new EntityProperty(data));
// Insert
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Insert(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Insert(ent));
}
// Retrieve
TableResult res = null;
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
// Check equality
DynamicTableEntity retrievedEntity = res.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Query using data filter
TableQuery query = new TableQuery();
query.Where(string.Format(
"(PartitionKey eq \'{0}\') and (RowKey eq \'{1}\') and (foo eq \'{2}\')",
ent.PartitionKey,
ent.RowKey,
data.Replace("\'", "\'\'")));
retrievedEntity = currentTable.ExecuteQuery(query).Single();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Merge
ent.Properties.Add("foo2", new EntityProperty("bar2"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Merge(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Merge(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
// Replace
ent.Properties.Remove("foo2");
ent.Properties.Add("foo3", new EntityProperty("bar3"));
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(ent);
currentTable.ExecuteBatch(batch);
}
else
{
currentTable.Execute(TableOperation.Replace(ent));
}
// Retrieve
if (useBatch)
{
TableBatchOperation batch = new TableBatchOperation();
batch.Retrieve(ent.PartitionKey, ent.RowKey);
res = (currentTable.ExecuteBatch(batch))[0];
}
else
{
res = currentTable.Execute(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey));
}
retrievedEntity = res.Result as DynamicTableEntity;
Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey);
Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey);
Assert.AreEqual(ent.ETag, retrievedEntity.ETag);
Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]);
}
internal Task <TableQuerySegment> ExecuteQuerySegmentedAsync(string tableName, TableQuery query, TableContinuationToken token, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
CommonUtility.AssertNotNull("query", query);
return(query.ExecuteQuerySegmentedAsync(token, this, tableName, requestOptions, operationContext, cancellationToken));
}
//Azure SDK changes, you are killing me.
public static IEnumerable <DynamicTableEntity> ExecuteQuery(this CloudTable ct, TableQuery tq)
{
var task = ct.ExecuteQuerySegmentedAsync(tq, new TableContinuationToken());
task.Wait();
var segment = task.Result;
TableContinuationToken t = segment.ContinuationToken;
if (t == null)
{
return(segment.Results);
}
else
{
List <DynamicTableEntity> tlist = new List <DynamicTableEntity>(segment.Results);
while (t != null)
{
var task2 = ct.ExecuteQuerySegmentedAsync(tq, t);
task2.Wait();
segment = task2.Result;
tlist.AddRange(segment.Results);
t = segment.ContinuationToken;
}
return(tlist);
}
}
public IEnumerable<SiloMetricsTable> QuerySiloMetrics(string deploymentId)
{
var table = this.TableClient.GetTableReference("OrleansSiloMetrics");
var query = new TableQuery<SiloMetricsTable>();
query.Where(TableQuery.GenerateFilterCondition("PartitionKey", "eq", deploymentId));
return table.ExecuteQuery(query);
}
