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); }