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