internal async Task <List <(ReminderTableEntry Entity, string ETag)> > FindReminderEntries(uint begin, uint end) { string sBegin = ReminderTableEntry.ConstructPartitionKey(ServiceId, begin); string sEnd = ReminderTableEntry.ConstructPartitionKey(ServiceId, end); string query; if (begin < end) { // Query between the specified lower and upper bounds. // Note that the lower bound is exclusive and the upper bound is inclusive in the below query. query = TableClient.CreateQueryFilter($"(PartitionKey gt {sBegin}) and (PartitionKey le {sEnd})"); } else { var(partitionKeyLowerBound, partitionKeyUpperBound) = ReminderTableEntry.ConstructPartitionKeyBounds(ServiceId); if (begin == end) { // Query the entire range query = TableClient.CreateQueryFilter($"(PartitionKey gt {partitionKeyLowerBound}) and (PartitionKey lt {partitionKeyUpperBound})"); } else { // (begin > end) // Query wraps around the ends of the range, so the query is the union of two disjunct queries // Include everything outside of the (begin, end] range, which wraps around to become: // [partitionKeyLowerBound, end] OR (begin, partitionKeyUpperBound] Debug.Assert(begin > end); query = TableClient.CreateQueryFilter($"((PartitionKey gt {partitionKeyLowerBound}) and (PartitionKey le {sEnd})) or ((PartitionKey gt {sBegin}) and (PartitionKey lt {partitionKeyUpperBound}))"); } } var queryResults = await ReadTableEntriesAndEtagsAsync(query); return(queryResults.ToList()); }
private async Task UnregisterManyBlock(List <GrainAddress> addresses) { var queryBuilder = new StringBuilder(); queryBuilder.Append(TableClient.CreateQueryFilter($"(PartitionKey eq {clusterId}) and (")); var first = true; foreach (var addr in addresses) { if (!first) { queryBuilder.Append(" or "); } else { first = false; } var rowKey = GrainDirectoryEntity.GrainIdToRowKey(addr.GrainId); var queryClause = TableClient.CreateQueryFilter($"((RowKey eq {rowKey}) and (ActivationId eq {addr.ActivationId.ToString()}))"); queryBuilder.Append(queryClause); } queryBuilder.Append(')'); var entities = await this.tableDataManager.ReadTableEntriesAndEtagsAsync(queryBuilder.ToString()); await this.tableDataManager.DeleteTableEntriesAsync(entities); }
internal async Task <List <(ReminderTableEntry Entity, string ETag)> > FindReminderEntries(GrainReference grainRef) { var partitionKey = ReminderTableEntry.ConstructPartitionKey(ServiceId, grainRef); var(rowKeyLowerBound, rowKeyUpperBound) = ReminderTableEntry.ConstructRowKeyBounds(grainRef); var query = TableClient.CreateQueryFilter($"(PartitionKey eq {partitionKey}) and ((RowKey gt {rowKeyLowerBound}) and (RowKey le {rowKeyUpperBound}))"); var queryResults = await ReadTableEntriesAndEtagsAsync(query); return(queryResults.ToList()); }
public static string SearchStatesQuery( string oneFuzzVersion, Guid?poolId = default, Guid?scaleSetId = default, IEnumerable <NodeState>?states = default, PoolName?poolName = default, bool excludeUpdateScheduled = false, int?numResults = default) { List <string> queryParts = new(); if (poolId is not null) { queryParts.Add($"(pool_id eq '{poolId}')"); } if (poolName is not null) { queryParts.Add($"(PartitionKey eq '{poolName}')"); } if (scaleSetId is not null) { queryParts.Add($"(scaleset_id eq '{scaleSetId}')"); } if (states is not null) { var q = Query.EqualAnyEnum("state", states); queryParts.Add($"({q})"); } if (excludeUpdateScheduled) { queryParts.Add($"reimage_requested eq false"); queryParts.Add($"delete_requested eq false"); } //# azure table query always return false when the column does not exist //# We write the query this way to allow us to get the nodes where the //# version is not defined as well as the nodes with a mismatched version var versionQuery = TableClient.CreateQueryFilter($"not (version eq {oneFuzzVersion})"); queryParts.Add(versionQuery); return(Query.And(queryParts)); }
// Used as an alternative to binding to IQueryable. private async Task <JArray> CreateJArray(TableAttribute attribute, CancellationToken cancellation) { var table = GetTable(attribute); string filter = attribute.Filter; if (!string.IsNullOrEmpty(attribute.PartitionKey)) { var partitionKeyPredicate = TableClient.CreateQueryFilter($"PartitionKey eq {attribute.PartitionKey}"); if (!string.IsNullOrEmpty(filter)) { filter = $"{partitionKeyPredicate} and {filter}"; } else { filter = partitionKeyPredicate; } } int?maxPerPage = null; if (attribute.Take > 0) { maxPerPage = attribute.Take; } int countRemaining = attribute.Take; JArray entityArray = new JArray(); var entities = table.QueryAsync <TableEntity>( filter: filter, maxPerPage: maxPerPage, cancellationToken: cancellation).ConfigureAwait(false); await foreach (var entity in entities) { countRemaining--; entityArray.Add(ConvertEntityToJObject(entity)); if (countRemaining == 0) { break; } } return(entityArray); }
public async Task TableQueryableComplexFilterWithCreateFilter() { var entitiesToCreate = CreateComplexTableEntities(PartitionKeyValue, 4); // Create the new entities. await CreateTestEntities(entitiesToCreate).ConfigureAwait(false); var filter = TableClient.CreateQueryFilter <ComplexEntity>(ent => (ent.RowKey == "0004" && ent.Int32 == 4) || ((ent.Int32 == 2) && (ent.String == "wrong string" || ent.Bool == true)) || (ent.LongPrimitiveN == (long)int.MaxValue + 50)); var results = await client.QueryAsync <ComplexEntity>(filter).ToEnumerableAsync().ConfigureAwait(false); foreach (ComplexEntity ent in results) { Assert.IsTrue(ent.Int32 == 4 || ent.Int32 == 2); } Assert.That(results.Count, Is.EqualTo(2)); }
public void QueryEntities() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies4p1"; string partitionKey = "somePartition"; string rowKey = "1"; string rowKey2 = "2"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); serviceClient.CreateTable(tableName); var tableClient = serviceClient.GetTableClient(tableName); var entity = new TableEntity(partitionKey, rowKey) { { "Product", "Markers" }, { "Price", 5.00 }, { "Quantity", 34 } }; tableClient.AddEntity(entity); var entity2 = new TableEntity(partitionKey, rowKey2) { { "Product", "Planner" }, { "Price", 7.00 }, { "Quantity", 34 } }; tableClient.AddEntity(entity2); #region Snippet:TablesSample4QueryEntitiesFilter Pageable <TableEntity> queryResultsFilter = tableClient.Query <TableEntity>(filter: $"PartitionKey eq '{partitionKey}'"); // Iterate the <see cref="Pageable"> to access all queried entities. foreach (TableEntity qEntity in queryResultsFilter) { Console.WriteLine($"{qEntity.GetString("Product")}: {qEntity.GetDouble("Price")}"); } Console.WriteLine($"The query returned {queryResultsFilter.Count()} entities."); #endregion #region Snippet:TablesSample4QueryEntitiesFilterWithQueryFilter // The CreateQueryFilter method is also available to assist with properly formatting and escaping OData queries. #if SNIPPET Pageable <TableEntity> queryResultsFilter = tableClient.Query <TableEntity>(filter: TableClient.CreateQueryFilter($"PartitionKey eq {partitionKey}")); #else queryResultsFilter = tableClient.Query <TableEntity>(filter: TableClient.CreateQueryFilter($"PartitionKey eq {partitionKey}")); #endif // Iterate the <see cref="Pageable"> to access all queried entities. foreach (TableEntity qEntity in queryResultsFilter) { Console.WriteLine($"{qEntity.GetString("Product")}: {qEntity.GetDouble("Price")}"); } Console.WriteLine($"The query returned {queryResultsFilter.Count()} entities."); // It handles esca #endregion #region Snippet:TablesSample4QueryEntitiesExpression // Use the <see cref="TableClient"> to query the table using a filter expression. double priceCutOff = 6.00; Pageable <OfficeSupplyEntity> queryResultsLINQ = tableClient.Query <OfficeSupplyEntity>(ent => ent.Price >= priceCutOff); #endregion #region Snippet:TablesSample4QueryEntitiesSelect Pageable <TableEntity> queryResultsSelect = tableClient.Query <TableEntity>(select: new List <string>() { "Product", "Price" }); #endregion #region Snippet:TablesSample4QueryEntitiesMaxPerPage Pageable <TableEntity> queryResultsMaxPerPage = tableClient.Query <TableEntity>(maxPerPage: 10); // Iterate the <see cref="Pageable"> by page. foreach (Page <TableEntity> page in queryResultsMaxPerPage.AsPages()) { Console.WriteLine("This is a new page!"); foreach (TableEntity qEntity in page.Values) { Console.WriteLine($"# of {qEntity.GetString("Product")} inventoried: {qEntity.GetInt32("Quantity")}"); } } #endregion serviceClient.DeleteTable(tableName); }
public async Task <IList <Uri> > FindAllGatewayProxyEndpoints() { if (logger.IsEnabled(LogLevel.Debug)) { logger.LogDebug((int)ErrorCode.Runtime_Error_100277, "Searching for active gateway silos for deployment {DeploymentId}.", this.DeploymentId); } try { const string Active = nameof(SiloStatus.Active); const string Zero = "0"; var queryResults = await storage.ReadTableEntriesAndEtagsAsync(TableClient.CreateQueryFilter($"PartitionKey eq {DeploymentId} and Status eq {Active} and ProxyPort ne {Zero}")); var gatewaySiloInstances = queryResults.Select(entity => ConvertToGatewayUri(entity.Item1)).ToList(); logger.LogInformation((int)ErrorCode.Runtime_Error_100278, "Found {GatewaySiloCount} active Gateway Silos for deployment {DeploymentId}.", gatewaySiloInstances.Count, this.DeploymentId); return(gatewaySiloInstances); }catch (Exception exc) { logger.LogError((int)ErrorCode.Runtime_Error_100331, exc, "Error searching for active gateway silos for deployment {DeploymentId} ", this.DeploymentId); throw; } }
public static string SingleEntity(string partitionKey, string rowKey) => TableClient.CreateQueryFilter($"(PartitionKey eq {partitionKey}) and (RowKey eq {rowKey})");
public static string RowKey(string rowKey) => TableClient.CreateQueryFilter($"RowKey eq {rowKey}");
internal static string PointQuery(string partitionKey, string rowKey) { return(TableClient.CreateQueryFilter($"(PartitionKey eq {partitionKey}) and (RowKey eq {rowKey})")); }
internal static string RangeQuery(string partitionKey, string minRowKey, string maxRowKey) { return(TableClient.CreateQueryFilter($"((PartitionKey eq {partitionKey}) and (RowKey ge {minRowKey})) and (RowKey le {maxRowKey})")); }
public static string TimeRange(DateTimeOffset min, DateTimeOffset max) { // NB: this uses the auto-populated Timestamp property, and will result in a table scan // TODO: should this be inclusive at the endpoints? return(TableClient.CreateQueryFilter($"Timestamp lt {max} and Timestamp gt {min}")); }
public void TestDynamicTableEntityFilterExpressions(string expectedFilter, Expression <Func <DynamicTableEntity, bool> > expression) { var filter = TableClient.CreateQueryFilter(expression); Assert.That(filter, Is.EqualTo(expectedFilter)); }
// For all queries below, note that TableClient.CreateQueryFilter takes a FormattableString // and handles escaping the interpolated values properly. It also handles quoting the values // where needed, so use {string} and not '{string}'. public static string PartitionKey(string partitionKey) => TableClient.CreateQueryFilter($"PartitionKey eq {partitionKey}");
public IAsyncEnumerable <Pool> GetByClientId(Guid clientId) { return(QueryAsync(filter: TableClient.CreateQueryFilter($"client_id eq {clientId}"))); }
public IAsyncEnumerable <Node> SearchByPoolName(PoolName poolName) { return(QueryAsync(TableClient.CreateQueryFilter($"(pool_name eq {poolName})"))); }