// batching is not supported for query unless you do a range query #if FALSE private IList <TableResult> BatchContains(CloudTable table, HashEntity[] entries) { // Create the batch operation. TableBatchOperation batchOperation = new TableBatchOperation(); // The following code generates test data for use during the query samples. foreach (var entry in entries) { batchOperation.Retrieve <HashEntity>(entry.PartitionKey, entry.RowKey); } // Execute the batch operation. IList <TableResult> results = table.ExecuteBatch(batchOperation); foreach (var result in results) { var r = result.Result as HashEntity; if (r == null) { continue; } // propagate info to outer collection var entry = entries.First(x => x.RowKey.SequenceEqual(r.RowKey)); entry.FoundInDB = true; } Interlocked.Add(ref TotalUpdated, results.Count); if ((TotalUpdated % 1000) == 0) { WriteColor(ConsoleColor.Cyan, $"DB read {TotalUpdated:N0} entries. {(TotalUpdated) / UploadedSW.Elapsed.TotalSeconds} per second. Task time: {UploadedSW.Elapsed}"); } return(results); }
public void TableBatchRetrieveSync() { string pk = Guid.NewGuid().ToString(); // Add insert DynamicReplicatedTableEntity sendEnt = GenerateRandomEnitity(pk); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexIEntity().WriteEntity(null); TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve <DynamicReplicatedTableEntity>(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList <TableResult> results = this.repTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity this.repTable.Execute(TableOperation.Insert(sendEnt)); // Success results = this.repTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicReplicatedTableEntity retrievedEntity = results.First().Result as DynamicReplicatedTableEntity; // Validate entity Assert.AreEqual(sendEnt["String"], retrievedEntity["String"]); Assert.AreEqual(sendEnt["Int64"], retrievedEntity["Int64"]); Assert.AreEqual(sendEnt["Int64N"], retrievedEntity["Int64N"]); Assert.AreEqual(sendEnt["LongPrimitive"], retrievedEntity["LongPrimitive"]); Assert.AreEqual(sendEnt["LongPrimitiveN"], retrievedEntity["LongPrimitiveN"]); Assert.AreEqual(sendEnt["Int32"], retrievedEntity["Int32"]); Assert.AreEqual(sendEnt["Int32N"], retrievedEntity["Int32N"]); Assert.AreEqual(sendEnt["IntegerPrimitive"], retrievedEntity["IntegerPrimitive"]); Assert.AreEqual(sendEnt["IntegerPrimitiveN"], retrievedEntity["IntegerPrimitiveN"]); Assert.AreEqual(sendEnt["Guid"], retrievedEntity["Guid"]); Assert.AreEqual(sendEnt["GuidN"], retrievedEntity["GuidN"]); Assert.AreEqual(sendEnt["Double"], retrievedEntity["Double"]); Assert.AreEqual(sendEnt["DoubleN"], retrievedEntity["DoubleN"]); Assert.AreEqual(sendEnt["DoublePrimitive"], retrievedEntity["DoublePrimitive"]); Assert.AreEqual(sendEnt["DoublePrimitiveN"], retrievedEntity["DoublePrimitiveN"]); Assert.AreEqual(sendEnt["BinaryPrimitive"], retrievedEntity["BinaryPrimitive"]); Assert.AreEqual(sendEnt["Binary"], retrievedEntity["Binary"]); Assert.AreEqual(sendEnt["BoolPrimitive"], retrievedEntity["BoolPrimitive"]); Assert.AreEqual(sendEnt["BoolPrimitiveN"], retrievedEntity["BoolPrimitiveN"]); Assert.AreEqual(sendEnt["Bool"], retrievedEntity["Bool"]); Assert.AreEqual(sendEnt["BoolN"], retrievedEntity["BoolN"]); Assert.AreEqual(sendEnt["DateTimeOffsetN"], retrievedEntity["DateTimeOffsetN"]); Assert.AreEqual(sendEnt["DateTimeOffset"], retrievedEntity["DateTimeOffset"]); Assert.AreEqual(sendEnt["DateTime"], retrievedEntity["DateTime"]); Assert.AreEqual(sendEnt["DateTimeN"], retrievedEntity["DateTimeN"]); }
public void TableBatchAddMultiQueryShouldThrow() { TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve("foo", "bar"); try { batch.Retrieve("foo", "bar2"); Assert.Fail(); } catch (ArgumentException) { // no op } catch (Exception) { Assert.Fail(); } }
internal static TableBatchOperation BuildReadOperation(IReadOnlyList <Sha1> sha1s) { var batch = new TableBatchOperation(); if (sha1s != null && sha1s.Count > 0) { for (var i = 0; i < sha1s.Count; i++) { var partitionKey = GetPartitionKey(sha1s[i]); var rowKey = GetRowKey(sha1s[i]); batch.Retrieve <DataEntity>(partitionKey, rowKey); } } return(batch); }
public static IEnumerable <TableBatchInformation <T> > RetrieveAll <T>(this IEnumerable <IEnumerable <EntityKey> > batches) where T : ITableEntity { foreach (var batch in batches.Select(b => b.ToArray())) { foreach (var instance in batch) { /* NOTE: only one retrieve allowed for each record. it throws otherwise. */ var operation = new TableBatchOperation(); operation.Retrieve <T>(instance.PartitionKey, instance.RowKey); yield return(new TableBatchInformation <T>(operation, new T[] {}, TableOperationType.Retrieve));; } } }
public async Task <IEnumerable <IAggregatedEvent> > FetchTimeSeriesAggregatedEventsAsync(IEnumerable <int> artistWorkIds, TimeSeries timeSeries) { List <TimeSeriesValueEntity> entities = new List <TimeSeriesValueEntity>(); if (!artistWorkIds.Any()) { var query = new TableQuery <TimeSeriesValueEntity>().Where( TableQuery.GenerateFilterCondition( nameof(TimeSeriesValueEntity.TimeSeries), QueryComparisons.Equal, timeSeries.ToString()) ); entities = _cacheTable.ExecuteQuery(query).ToList(); } else { TableBatchOperation batchOperation = new TableBatchOperation(); foreach (var idBatch in artistWorkIds.Batch(50)) { foreach (var id in idBatch) { batchOperation.Retrieve <TimeSeriesValueEntity>(id.ToString(), timeSeries.ToString()); } TableBatchResult batchResult = await _cacheTable.ExecuteBatchAsync(batchOperation); entities.AddRange(batchResult.Select(x => (TimeSeriesValueEntity)x.Result)); batchOperation.Clear(); } } return(entities.Select(entity => { return new AggregatedEvent() { AggregatedEventSum = entity.TimeSeriesTotal, AggregationTimeSeries = entity.TimeSeries, Id = entity.ArtistWorkId, AggregatedEventSumSource = entity.TimeSeriesValues.Select(x => new AggregatedEventSource() { Timestamp = x.Timestamp, Value = x.Value }) }; })); }
public static void Execute <T>(this TableBatchOperation operation, TableOperationType type, T entity) where T : ITableEntity { switch (type) { case TableOperationType.Insert: operation.Insert(entity); break; case TableOperationType.Delete: operation.Delete(entity); break; case TableOperationType.Replace: operation.Replace(entity); break; case TableOperationType.Merge: operation.Merge(entity); break; case TableOperationType.InsertOrReplace: operation.InsertOrReplace(entity); break; case TableOperationType.InsertOrMerge: operation.InsertOrMerge(entity); break; case TableOperationType.Retrieve: operation.Retrieve(entity.PartitionKey, entity.RowKey); break; default: throw new Exception($"Invalid enum value {nameof(TableOperationType)} {type}"); } }
public void TableBatchOperationsWithEmptyKeys() { CloudTableClient tableClient = GenerateCloudTableClient(); // Insert Entity DynamicTableEntity ent = new DynamicTableEntity() { PartitionKey = "", RowKey = "" }; ent.Properties.Add("foo2", new EntityProperty("bar2")); ent.Properties.Add("foo", new EntityProperty("bar")); TableBatchOperation batch = new TableBatchOperation(); batch.Insert(ent); currentTable.ExecuteBatch(batch); // Retrieve Entity TableBatchOperation retrieveBatch = new TableBatchOperation(); retrieveBatch.Retrieve(ent.PartitionKey, ent.RowKey); TableResult result = currentTable.ExecuteBatch(retrieveBatch).First(); DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey); Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey); Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(ent.Properties["foo"].StringValue, retrievedEntity.Properties["foo"].StringValue); Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]); Assert.AreEqual(ent.Properties["foo2"].StringValue, retrievedEntity.Properties["foo2"].StringValue); Assert.AreEqual(ent.Properties["foo2"], retrievedEntity.Properties["foo2"]); // InsertOrMerge DynamicTableEntity insertOrMergeEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey); insertOrMergeEntity.Properties.Add("foo3", new EntityProperty("value")); batch = new TableBatchOperation(); batch.InsertOrMerge(insertOrMergeEntity); currentTable.ExecuteBatch(batch); result = currentTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(insertOrMergeEntity.Properties["foo3"], retrievedEntity.Properties["foo3"]); // InsertOrReplace DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey); insertOrReplaceEntity.Properties.Add("prop2", new EntityProperty("otherValue")); batch = new TableBatchOperation(); batch.InsertOrReplace(insertOrReplaceEntity); currentTable.ExecuteBatch(batch); result = currentTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(1, retrievedEntity.Properties.Count); Assert.AreEqual(insertOrReplaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]); // Merge DynamicTableEntity mergeEntity = new DynamicTableEntity(retrievedEntity.PartitionKey, retrievedEntity.RowKey) { ETag = retrievedEntity.ETag }; mergeEntity.Properties.Add("mergeProp", new EntityProperty("merged")); batch = new TableBatchOperation(); batch.Merge(mergeEntity); currentTable.ExecuteBatch(batch); // Retrieve Entity & Verify Contents result = currentTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(mergeEntity.Properties["mergeProp"], retrievedEntity.Properties["mergeProp"]); // Replace DynamicTableEntity replaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey) { ETag = retrievedEntity.ETag }; replaceEntity.Properties.Add("replaceProp", new EntityProperty("replace")); batch = new TableBatchOperation(); batch.Replace(replaceEntity); currentTable.ExecuteBatch(batch); // Retrieve Entity & Verify Contents result = currentTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(replaceEntity.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(replaceEntity.Properties["replaceProp"], retrievedEntity.Properties["replaceProp"]); // Delete Entity batch = new TableBatchOperation(); batch.Delete(retrievedEntity); currentTable.ExecuteBatch(batch); // Retrieve Entity result = currentTable.ExecuteBatch(retrieveBatch).First(); Assert.IsNull(result.Result); }
public void TableBatchRetrieveWithResolverAPM() { CloudTableClient tableClient = GenerateCloudTableClient(); // Add insert DynamicTableEntity sendEnt = GenerateRandomEnitity(Guid.NewGuid().ToString()); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); sendEnt.Properties.Add("foo", new EntityProperty("bar")); EntityResolver<string> resolver = (pk, rk, ts, props, etag) => pk + rk + props["foo"].StringValue + props.Count; TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey, resolver); // not found IList<TableResult> results = null; using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult asyncRes = null; currentTable.BeginExecuteBatch(batch, (res) => { asyncRes = res; evt.Set(); }, null); evt.WaitOne(); results = currentTable.EndExecuteBatch(asyncRes); } Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity currentTable.Execute(TableOperation.Insert(sendEnt)); // Success using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult asyncRes = null; currentTable.BeginExecuteBatch(batch, (res) => { asyncRes = res; evt.Set(); }, null); evt.WaitOne(); results = currentTable.EndExecuteBatch(asyncRes); } Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); Assert.AreEqual((string)results.First().Result, sendEnt.PartitionKey + sendEnt.RowKey + sendEnt["foo"].StringValue + sendEnt.Properties.Count); }
public void TableBatchRetrieveAPM() { CloudTableClient tableClient = GenerateCloudTableClient(); string pk = Guid.NewGuid().ToString(); // Add insert DynamicTableEntity sendEnt = GenerateRandomEnitity(pk); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList<TableResult> results = null; using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult asyncRes = null; currentTable.BeginExecuteBatch(batch, (res) => { asyncRes = res; evt.Set(); }, null); evt.WaitOne(); results = currentTable.EndExecuteBatch(asyncRes); } Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity currentTable.Execute(TableOperation.Insert(sendEnt)); // Success using (ManualResetEvent evt = new ManualResetEvent(false)) { IAsyncResult asyncRes = null; currentTable.BeginExecuteBatch(batch, (res) => { asyncRes = res; evt.Set(); }, null); evt.WaitOne(); results = currentTable.EndExecuteBatch(asyncRes); } Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicTableEntity retrievedEntity = results.First().Result as DynamicTableEntity; // Validate entity Assert.AreEqual(sendEnt["String"], retrievedEntity["String"]); Assert.AreEqual(sendEnt["Int64"], retrievedEntity["Int64"]); Assert.AreEqual(sendEnt["LongPrimitive"], retrievedEntity["LongPrimitive"]); Assert.AreEqual(sendEnt["Int32"], retrievedEntity["Int32"]); Assert.AreEqual(sendEnt["IntegerPrimitive"], retrievedEntity["IntegerPrimitive"]); Assert.AreEqual(sendEnt["Guid"], retrievedEntity["Guid"]); Assert.AreEqual(sendEnt["Double"], retrievedEntity["Double"]); Assert.AreEqual(sendEnt["DoublePrimitive"], retrievedEntity["DoublePrimitive"]); Assert.AreEqual(sendEnt["BinaryPrimitive"], retrievedEntity["BinaryPrimitive"]); Assert.AreEqual(sendEnt["Binary"], retrievedEntity["Binary"]); Assert.AreEqual(sendEnt["BoolPrimitive"], retrievedEntity["BoolPrimitive"]); Assert.AreEqual(sendEnt["Bool"], retrievedEntity["Bool"]); Assert.AreEqual(sendEnt["DateTimeOffsetN"], retrievedEntity["DateTimeOffsetN"]); Assert.AreEqual(sendEnt["DateTimeOffset"], retrievedEntity["DateTimeOffset"]); Assert.AreEqual(sendEnt["DateTime"], retrievedEntity["DateTime"]); Assert.AreEqual(sendEnt["DateTimeN"], retrievedEntity["DateTimeN"]); }
private async Task DoEscapeTestAsync(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); await currentTable.ExecuteBatchAsync(batch); } else { await currentTable.ExecuteAsync(TableOperation.Insert(ent)); } // Retrieve TableResult res = null; if (useBatch) { TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(ent.PartitionKey, ent.RowKey); res = (await currentTable.ExecuteBatchAsync(batch))[0]; } else { res = await currentTable.ExecuteAsync(TableOperation.Retrieve(ent.PartitionKey, ent.RowKey)); } // Check equality DynamicTableEntity 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"]); // Merge ent.Properties.Add("foo2", new EntityProperty("bar2")); if (useBatch) { TableBatchOperation batch = new TableBatchOperation(); batch.Merge(ent); await currentTable.ExecuteBatchAsync(batch); } else { await currentTable.ExecuteAsync(TableOperation.Merge(ent)); } // Retrieve if (useBatch) { TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(ent.PartitionKey, ent.RowKey); res = (await currentTable.ExecuteBatchAsync(batch))[0]; } else { res = await currentTable.ExecuteAsync(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); await currentTable.ExecuteBatchAsync(batch); } else { await currentTable.ExecuteAsync(TableOperation.Replace(ent)); } // Retrieve if (useBatch) { TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(ent.PartitionKey, ent.RowKey); res = (await currentTable.ExecuteBatchAsync(batch))[0]; } else { res = await currentTable.ExecuteAsync(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"]); }
private async Task DoTableBatchOperationsWithEmptyKeysAsync(TablePayloadFormat format) { tableClient.DefaultRequestOptions.PayloadFormat = format; // Insert Entity DynamicTableEntity ent = new DynamicTableEntity() { PartitionKey = "", RowKey = "" }; ent.Properties.Add("foo2", new EntityProperty("bar2")); ent.Properties.Add("foo", new EntityProperty("bar")); TableBatchOperation batch = new TableBatchOperation(); batch.Insert(ent); await currentTable.ExecuteBatchAsync(batch); // Retrieve Entity TableBatchOperation retrieveBatch = new TableBatchOperation(); retrieveBatch.Retrieve(ent.PartitionKey, ent.RowKey); TableResult result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey); Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey); Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(ent.Properties["foo"].StringValue, retrievedEntity.Properties["foo"].StringValue); Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]); Assert.AreEqual(ent.Properties["foo2"].StringValue, retrievedEntity.Properties["foo2"].StringValue); Assert.AreEqual(ent.Properties["foo2"], retrievedEntity.Properties["foo2"]); // InsertOrMerge DynamicTableEntity insertOrMergeEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey); insertOrMergeEntity.Properties.Add("foo3", new EntityProperty("value")); batch = new TableBatchOperation(); batch.InsertOrMerge(insertOrMergeEntity); await currentTable.ExecuteBatchAsync(batch); result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(insertOrMergeEntity.Properties["foo3"], retrievedEntity.Properties["foo3"]); // InsertOrReplace DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey); insertOrReplaceEntity.Properties.Add("prop2", new EntityProperty("otherValue")); batch = new TableBatchOperation(); batch.InsertOrReplace(insertOrReplaceEntity); await currentTable.ExecuteBatchAsync(batch); result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(1, retrievedEntity.Properties.Count); Assert.AreEqual(insertOrReplaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]); // Merge DynamicTableEntity mergeEntity = new DynamicTableEntity(retrievedEntity.PartitionKey, retrievedEntity.RowKey) { ETag = retrievedEntity.ETag }; mergeEntity.Properties.Add("mergeProp", new EntityProperty("merged")); batch = new TableBatchOperation(); batch.Merge(mergeEntity); await currentTable.ExecuteBatchAsync(batch); // Retrieve Entity & Verify Contents result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(mergeEntity.Properties["mergeProp"], retrievedEntity.Properties["mergeProp"]); // Replace DynamicTableEntity replaceEntity = new DynamicTableEntity(ent.PartitionKey, ent.RowKey) { ETag = retrievedEntity.ETag }; replaceEntity.Properties.Add("replaceProp", new EntityProperty("replace")); batch = new TableBatchOperation(); batch.Replace(replaceEntity); await currentTable.ExecuteBatchAsync(batch); // Retrieve Entity & Verify Contents result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); retrievedEntity = result.Result as DynamicTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(replaceEntity.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(replaceEntity.Properties["replaceProp"], retrievedEntity.Properties["replaceProp"]); // Delete Entity batch = new TableBatchOperation(); batch.Delete(retrievedEntity); await currentTable.ExecuteBatchAsync(batch); // Retrieve Entity result = (await currentTable.ExecuteBatchAsync(retrieveBatch)).First(); Assert.IsNull(result.Result); }
private async Task DoTableBatchRetrieveAsync(TablePayloadFormat format) { tableClient.DefaultRequestOptions.PayloadFormat = format; string pk = Guid.NewGuid().ToString(); // Add insert DynamicTableEntity sendEnt = GenerateRandomEntity(pk); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); TableRequestOptions options = new TableRequestOptions() { PropertyResolver = (partitionKey, rowKey, propName, propValue) => ComplexEntity.ComplexEntityPropertyResolver(partitionKey, rowKey, propName, propValue) }; TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList<TableResult> results = await currentTable.ExecuteBatchAsync(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity await currentTable.ExecuteAsync(TableOperation.Insert(sendEnt)); // Success results = await currentTable.ExecuteBatchAsync(batch, options, null); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicTableEntity retrievedEntity = results.First().Result as DynamicTableEntity; // Validate entity Assert.AreEqual(sendEnt.Properties["String"], retrievedEntity.Properties["String"]); Assert.AreEqual(sendEnt.Properties["Int64"], retrievedEntity.Properties["Int64"]); Assert.AreEqual(sendEnt.Properties["Int64N"], retrievedEntity.Properties["Int64N"]); Assert.AreEqual(sendEnt.Properties["LongPrimitive"], retrievedEntity.Properties["LongPrimitive"]); Assert.AreEqual(sendEnt.Properties["LongPrimitiveN"], retrievedEntity.Properties["LongPrimitiveN"]); Assert.AreEqual(sendEnt.Properties["Int32"], retrievedEntity.Properties["Int32"]); Assert.AreEqual(sendEnt.Properties["Int32N"], retrievedEntity.Properties["Int32N"]); Assert.AreEqual(sendEnt.Properties["IntegerPrimitive"], retrievedEntity.Properties["IntegerPrimitive"]); Assert.AreEqual(sendEnt.Properties["IntegerPrimitiveN"], retrievedEntity.Properties["IntegerPrimitiveN"]); Assert.AreEqual(sendEnt.Properties["Guid"], retrievedEntity.Properties["Guid"]); Assert.AreEqual(sendEnt.Properties["GuidN"], retrievedEntity.Properties["GuidN"]); Assert.AreEqual(sendEnt.Properties["Double"], retrievedEntity.Properties["Double"]); Assert.AreEqual(sendEnt.Properties["DoubleN"], retrievedEntity.Properties["DoubleN"]); Assert.AreEqual(sendEnt.Properties["DoublePrimitive"], retrievedEntity.Properties["DoublePrimitive"]); Assert.AreEqual(sendEnt.Properties["DoublePrimitiveN"], retrievedEntity.Properties["DoublePrimitiveN"]); Assert.AreEqual(sendEnt.Properties["BinaryPrimitive"], retrievedEntity.Properties["BinaryPrimitive"]); Assert.AreEqual(sendEnt.Properties["Binary"], retrievedEntity.Properties["Binary"]); Assert.AreEqual(sendEnt.Properties["BoolPrimitive"], retrievedEntity.Properties["BoolPrimitive"]); Assert.AreEqual(sendEnt.Properties["BoolPrimitiveN"], retrievedEntity.Properties["BoolPrimitiveN"]); Assert.AreEqual(sendEnt.Properties["Bool"], retrievedEntity.Properties["Bool"]); Assert.AreEqual(sendEnt.Properties["BoolN"], retrievedEntity.Properties["BoolN"]); Assert.AreEqual(sendEnt.Properties["DateTimeOffsetN"], retrievedEntity.Properties["DateTimeOffsetN"]); Assert.AreEqual(sendEnt.Properties["DateTimeOffset"], retrievedEntity.Properties["DateTimeOffset"]); Assert.AreEqual(sendEnt.Properties["DateTime"], retrievedEntity.Properties["DateTime"]); Assert.AreEqual(sendEnt.Properties["DateTimeN"], retrievedEntity.Properties["DateTimeN"]); }
public void TableBatchOperationsWithEmptyKeys() { // Insert Entity DynamicReplicatedTableEntity ent = new DynamicReplicatedTableEntity() { PartitionKey = "", RowKey = "" }; ent.Properties.Add("foo2", new EntityProperty("bar2")); ent.Properties.Add("foo", new EntityProperty("bar")); TableBatchOperation batch = new TableBatchOperation(); batch.Insert(ent); this.repTable.ExecuteBatch(batch); // Retrieve Entity TableBatchOperation retrieveBatch = new TableBatchOperation(); retrieveBatch.Retrieve <DynamicReplicatedTableEntity>(ent.PartitionKey, ent.RowKey); TableResult result = this.repTable.ExecuteBatch(retrieveBatch).First(); DynamicReplicatedTableEntity retrievedEntity = result.Result as DynamicReplicatedTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(ent.PartitionKey, retrievedEntity.PartitionKey); Assert.AreEqual(ent.RowKey, retrievedEntity.RowKey); Assert.AreEqual(ent.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(ent.Properties["foo"].StringValue, retrievedEntity.Properties["foo"].StringValue); Assert.AreEqual(ent.Properties["foo"], retrievedEntity.Properties["foo"]); Assert.AreEqual(ent.Properties["foo2"].StringValue, retrievedEntity.Properties["foo2"].StringValue); Assert.AreEqual(ent.Properties["foo2"], retrievedEntity.Properties["foo2"]); // InsertOrMerge DynamicReplicatedTableEntity insertOrMergeEntity = new DynamicReplicatedTableEntity(ent.PartitionKey, ent.RowKey); insertOrMergeEntity.Properties.Add("foo3", new EntityProperty("value")); batch = new TableBatchOperation(); batch.InsertOrMerge(insertOrMergeEntity); this.repTable.ExecuteBatch(batch); result = this.repTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicReplicatedTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(insertOrMergeEntity.Properties["foo3"], retrievedEntity.Properties["foo3"]); // InsertOrReplace DynamicReplicatedTableEntity insertOrReplaceEntity = new DynamicReplicatedTableEntity(ent.PartitionKey, ent.RowKey); insertOrReplaceEntity.Properties.Add("prop2", new EntityProperty("otherValue")); batch = new TableBatchOperation(); batch.InsertOrReplace(insertOrReplaceEntity); this.repTable.ExecuteBatch(batch); result = this.repTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicReplicatedTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(1, retrievedEntity.Properties.Count); Assert.AreEqual(insertOrReplaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]); // Merge DynamicReplicatedTableEntity mergeEntity = new DynamicReplicatedTableEntity(retrievedEntity.PartitionKey, retrievedEntity.RowKey) { ETag = retrievedEntity.ETag }; mergeEntity.Properties.Add("mergeProp", new EntityProperty("merged")); batch = new TableBatchOperation(); batch.Merge(mergeEntity); this.repTable.ExecuteBatch(batch); // Retrieve Entity & Verify Contents result = this.repTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicReplicatedTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(mergeEntity.Properties["mergeProp"], retrievedEntity.Properties["mergeProp"]); // Replace DynamicReplicatedTableEntity replaceEntity = new DynamicReplicatedTableEntity(ent.PartitionKey, ent.RowKey) { ETag = retrievedEntity.ETag }; replaceEntity.Properties.Add("replaceProp", new EntityProperty("replace")); batch = new TableBatchOperation(); batch.Replace(replaceEntity); this.repTable.ExecuteBatch(batch); // Retrieve Entity & Verify Contents result = this.repTable.ExecuteBatch(retrieveBatch).First(); retrievedEntity = result.Result as DynamicReplicatedTableEntity; Assert.IsNotNull(retrievedEntity); Assert.AreEqual(replaceEntity.Properties.Count, retrievedEntity.Properties.Count); Assert.AreEqual(replaceEntity.Properties["replaceProp"], retrievedEntity.Properties["replaceProp"]); // Delete Entity batch = new TableBatchOperation(); batch.Delete(retrievedEntity); this.repTable.ExecuteBatch(batch); // Retrieve Entity result = this.repTable.ExecuteBatch(retrieveBatch).First(); Assert.IsNull(result.Result); }
private void DoTableBatchRetrieveEncryptedEntitySync(TablePayloadFormat format) { tableClient.DefaultRequestOptions.PayloadFormat = format; // Create the Key to be used for wrapping. SymmetricKey aesKey = new SymmetricKey("symencryptionkey"); TableRequestOptions options = new TableRequestOptions() { EncryptionPolicy = new TableEncryptionPolicy(aesKey, null), EncryptionResolver = (pk, rk, propName) => { if (propName == "A" || propName == "B") { return true; } return false; } }; // Add insert DynamicTableEntity sendEnt = GenerateRandomEntity(Guid.NewGuid().ToString()); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); sendEnt.Properties.Add("foo", new EntityProperty("bar")); TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve<DynamicTableEntity>(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList<TableResult> results = currentTable.ExecuteBatch(batch, options); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity currentTable.Execute(TableOperation.Insert(sendEnt), options); // Create the resolver to be used for unwrapping. DictionaryKeyResolver resolver = new DictionaryKeyResolver(); resolver.Add(aesKey); TableRequestOptions retrieveOptions = new TableRequestOptions() { EncryptionPolicy = new TableEncryptionPolicy(null, resolver) }; // Success results = currentTable.ExecuteBatch(batch, retrieveOptions); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicTableEntity retrievedEntity = results.First().Result as DynamicTableEntity; // Validate entity Assert.AreEqual(sendEnt["foo"], retrievedEntity["foo"]); }
public async Task TableBatchOnSecondaryAsync() { AssertSecondaryEndpoint(); CloudTable table = GenerateCloudTableClient().GetTableReference(GenerateRandomTableName()); TableRequestOptions options = new TableRequestOptions() { LocationMode = LocationMode.SecondaryOnly, RetryPolicy = new NoRetry(), }; TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve("PartitionKey", "RowKey"); OperationContext context = new OperationContext(); await table.ExecuteBatchAsync(batch, options, context); Assert.AreEqual(StorageLocation.Secondary, context.LastResult.TargetLocation); batch = new TableBatchOperation(); batch.Insert(new DynamicTableEntity("PartitionKey", "RowKey")); StorageException e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); batch = new TableBatchOperation(); batch.InsertOrMerge(new DynamicTableEntity("PartitionKey", "RowKey")); e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); batch = new TableBatchOperation(); batch.InsertOrReplace(new DynamicTableEntity("PartitionKey", "RowKey")); e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); batch = new TableBatchOperation(); batch.Merge(new DynamicTableEntity("PartitionKey", "RowKey") { ETag = "*" }); e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); batch = new TableBatchOperation(); batch.Replace(new DynamicTableEntity("PartitionKey", "RowKey") { ETag = "*" }); e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); batch = new TableBatchOperation(); batch.Delete(new DynamicTableEntity("PartitionKey", "RowKey") { ETag = "*" }); e = await TestHelper.ExpectedExceptionAsync<StorageException>( async () => await table.ExecuteBatchAsync(batch, options, null), "Batch operations other than retrieve should not be sent to secondary"); Assert.AreEqual(SR.PrimaryOnlyCommand, e.Message); }
public void TableBatchRetrieveSync() { string pk = Guid.NewGuid().ToString(); // Add insert DynamicReplicatedTableEntity sendEnt = GenerateRandomEnitity(pk); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexIEntity().WriteEntity(null); TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve<DynamicReplicatedTableEntity>(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList<TableResult> results = this.repTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity this.repTable.Execute(TableOperation.Insert(sendEnt)); // Success results = this.repTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicReplicatedTableEntity retrievedEntity = results.First().Result as DynamicReplicatedTableEntity; // Validate entity Assert.AreEqual(sendEnt["String"], retrievedEntity["String"]); Assert.AreEqual(sendEnt["Int64"], retrievedEntity["Int64"]); Assert.AreEqual(sendEnt["Int64N"], retrievedEntity["Int64N"]); Assert.AreEqual(sendEnt["LongPrimitive"], retrievedEntity["LongPrimitive"]); Assert.AreEqual(sendEnt["LongPrimitiveN"], retrievedEntity["LongPrimitiveN"]); Assert.AreEqual(sendEnt["Int32"], retrievedEntity["Int32"]); Assert.AreEqual(sendEnt["Int32N"], retrievedEntity["Int32N"]); Assert.AreEqual(sendEnt["IntegerPrimitive"], retrievedEntity["IntegerPrimitive"]); Assert.AreEqual(sendEnt["IntegerPrimitiveN"], retrievedEntity["IntegerPrimitiveN"]); Assert.AreEqual(sendEnt["Guid"], retrievedEntity["Guid"]); Assert.AreEqual(sendEnt["GuidN"], retrievedEntity["GuidN"]); Assert.AreEqual(sendEnt["Double"], retrievedEntity["Double"]); Assert.AreEqual(sendEnt["DoubleN"], retrievedEntity["DoubleN"]); Assert.AreEqual(sendEnt["DoublePrimitive"], retrievedEntity["DoublePrimitive"]); Assert.AreEqual(sendEnt["DoublePrimitiveN"], retrievedEntity["DoublePrimitiveN"]); Assert.AreEqual(sendEnt["BinaryPrimitive"], retrievedEntity["BinaryPrimitive"]); Assert.AreEqual(sendEnt["Binary"], retrievedEntity["Binary"]); Assert.AreEqual(sendEnt["BoolPrimitive"], retrievedEntity["BoolPrimitive"]); Assert.AreEqual(sendEnt["BoolPrimitiveN"], retrievedEntity["BoolPrimitiveN"]); Assert.AreEqual(sendEnt["Bool"], retrievedEntity["Bool"]); Assert.AreEqual(sendEnt["BoolN"], retrievedEntity["BoolN"]); Assert.AreEqual(sendEnt["DateTimeOffsetN"], retrievedEntity["DateTimeOffsetN"]); Assert.AreEqual(sendEnt["DateTimeOffset"], retrievedEntity["DateTimeOffset"]); Assert.AreEqual(sendEnt["DateTime"], retrievedEntity["DateTime"]); Assert.AreEqual(sendEnt["DateTimeN"], retrievedEntity["DateTimeN"]); }
private async Task DoTableBatchRetrieveWithResolverAsync(TablePayloadFormat format) { tableClient.DefaultRequestOptions.PayloadFormat = format; // Add insert DynamicTableEntity sendEnt = GenerateRandomEntity(Guid.NewGuid().ToString()); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); sendEnt.Properties.Add("foo", new EntityProperty("bar")); EntityResolver<string> resolver = (pk, rk, ts, props, etag) => pk + rk + props["foo"].StringValue + props.Count; TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey, resolver); // not found IList<TableResult> results = await currentTable.ExecuteBatchAsync(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity await currentTable.ExecuteAsync(TableOperation.Insert(sendEnt)); // Success results = await currentTable.ExecuteBatchAsync(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); // Since there are properties in ComplexEntity set to null, we do not receive those from the server. Hence we need to check for non null values. Assert.AreEqual((string)results.First().Result, sendEnt.PartitionKey + sendEnt.RowKey + sendEnt.Properties["foo"].StringValue + ComplexEntity.NumberOfNonNullProperties); }
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"]); }
private void DoTableBatchRetrieveWithITableEntitySync(TablePayloadFormat format) { tableClient.DefaultRequestOptions.PayloadFormat = format; // Add insert DynamicTableEntity sendEnt = GenerateRandomEntity(Guid.NewGuid().ToString()); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); sendEnt.Properties.Add("foo", new EntityProperty("bar")); TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve<DynamicTableEntity>(sendEnt.PartitionKey, sendEnt.RowKey); // not found IList<TableResult> results = currentTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity currentTable.Execute(TableOperation.Insert(sendEnt)); // Success results = currentTable.ExecuteBatch(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); DynamicTableEntity retrievedEntity = results.First().Result as DynamicTableEntity; // Validate entity Assert.AreEqual(sendEnt["foo"], retrievedEntity["foo"]); }
public async Task TableBatchRetrieveWithResolverAsync() { CloudTableClient tableClient = GenerateCloudTableClient(); // Add insert DynamicTableEntity sendEnt = GenerateRandomEnitity(Guid.NewGuid().ToString()); // generate a set of properties for all supported Types sendEnt.Properties = new ComplexEntity().WriteEntity(null); sendEnt.Properties.Add("foo", new EntityProperty("bar")); EntityResolver<string> resolver = (pk, rk, ts, props, etag) => pk + rk + props["foo"].StringValue + props.Count; TableBatchOperation batch = new TableBatchOperation(); batch.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey, resolver); // not found IList<TableResult> results = await currentTable.ExecuteBatchAsync(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.NotFound); Assert.IsNull(results.First().Result); Assert.IsNull(results.First().Etag); // insert entity await currentTable.ExecuteAsync(TableOperation.Insert(sendEnt)); // Success results = await currentTable.ExecuteBatchAsync(batch); Assert.AreEqual(results.Count, 1); Assert.AreEqual(results.First().HttpStatusCode, (int)HttpStatusCode.OK); Assert.AreEqual((string)results.First().Result, sendEnt.PartitionKey + sendEnt.RowKey + sendEnt.Properties["foo"].StringValue + sendEnt.Properties.Count); }