public async Task AddVersion(OwnershipRegistration registration, OwnershipOwner owner, string version)
{
CloudTableClient client = _account.CreateCloudTableClient();
CloudTable table = client.GetTableReference(OwnershipTableName);
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(new TypedEntity(registration.GetKey(), owner.GetKey(), OwnerType));
batch.InsertOrReplace(new TypedEntity(registration.GetKey(), version, PackageType));
await table.ExecuteBatchAsync(batch);
}
public TestFixture()
{
_config = new HttpConfiguration();
_config.Formatters.Add(new PlaintextMediaTypeFormatter());
_settingsManager = ScriptSettingsManager.Instance;
HostSettings = new WebHostSettings
{
IsSelfHost = true,
ScriptPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\sample"),
LogPath = Path.Combine(Path.GetTempPath(), @"Functions"),
SecretsPath = Path.Combine(Environment.CurrentDirectory, @"..\..\..\..\src\WebJobs.Script.WebHost\App_Data\Secrets")
};
WebApiConfig.Register(_config, _settingsManager, HostSettings);
HttpServer = new HttpServer(_config);
this.HttpClient = new HttpClient(HttpServer);
this.HttpClient.BaseAddress = new Uri("https://localhost/");
string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString("Storage");
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
BlobClient = storageAccount.CreateCloudBlobClient();
QueueClient = storageAccount.CreateCloudQueueClient();
TableClient = storageAccount.CreateCloudTableClient();
var table = TableClient.GetTableReference("samples");
table.CreateIfNotExists();
var batch = new TableBatchOperation();
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "1", Title = "Test Entity 1", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "2", Title = "Test Entity 2", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "3", Title = "Test Entity 3", Status = 1
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "4", Title = "Test Entity 4", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "5", Title = "Test Entity 5", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "6", Title = "Test Entity 6", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "7", Title = "Test Entity 7", Status = 0
});
table.ExecuteBatch(batch);
connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
NamespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
WaitForHost();
}
// public NamespaceManager NamespaceManager { get; set; }
protected override async Task CreateTestStorageEntities()
{
// Don't call base.
var table = TableClient.GetTableReference("samples");
await table.CreateIfNotExistsAsync();
var batch = new TableBatchOperation();
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "1", Title = "Test Entity 1", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "2", Title = "Test Entity 2", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "3", Title = "Test Entity 3", Status = 1
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "4", Title = "Test Entity 4", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "5", Title = "Test Entity 5", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "6", Title = "Test Entity 6", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "7", Title = "Test Entity 7", Status = 0
});
await table.ExecuteBatchAsync(batch);
// TODO: This currently throws
// string connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(ConnectionStringNames.ServiceBus);
// NamespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
}
protected override async Task CreateTestStorageEntities()
{
// Don't call base.
var table = TableClient.GetTableReference("samples");
await table.CreateIfNotExistsAsync();
var batch = new TableBatchOperation();
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "1", Title = "Test Entity 1", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "2", Title = "Test Entity 2", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "3", Title = "Test Entity 3", Status = 1
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "4", Title = "Test Entity 4", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "5", Title = "Test Entity 5", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "6", Title = "Test Entity 6", Status = 0
});
batch.InsertOrReplace(new TestEntity {
PartitionKey = "samples-python", RowKey = "7", Title = "Test Entity 7", Status = 0
});
await table.ExecuteBatchAsync(batch);
}
private void InitBank()
{
TableBatchOperation batchOperation = new TableBatchOperation();
Bank a1 = new Bank("1", 20000);
Bank a2 = new Bank("2", 1600);
Bank a3 = new Bank("3", 6000);
Bank a4 = new Bank("4", 9000);
Bank a5 = new Bank("5", 5000);
batchOperation.InsertOrReplace(a1);
batchOperation.InsertOrReplace(a2);
batchOperation.InsertOrReplace(a3);
batchOperation.InsertOrReplace(a4);
batchOperation.InsertOrReplace(a5);
_tableBank.ExecuteBatch(batchOperation);
}
private void InitBookstore()
{
TableBatchOperation batchOperation = new TableBatchOperation();
Bookstore a1 = new Bookstore("1", 5, 800);
Bookstore a2 = new Bookstore("2", 5, 900);
Bookstore a3 = new Bookstore("3", 5, 1000);
Bookstore a4 = new Bookstore("4", 5, 1100);
Bookstore a5 = new Bookstore("5", 5, 1500);
batchOperation.InsertOrReplace(a1);
batchOperation.InsertOrReplace(a2);
batchOperation.InsertOrReplace(a3);
batchOperation.InsertOrReplace(a4);
batchOperation.InsertOrReplace(a5);
_tableBookstore.ExecuteBatch(batchOperation);
}
private void InitStudents()
{
TableBatchOperation batchOperation = new TableBatchOperation();
Student a1 = new Student(1, "Ime1", "Prezime1");
Student a2 = new Student(2, "Ime2", "Prezime2");
Student a3 = new Student(3, "Ime3", "Prezime3");
Student a4 = new Student(4, "Ime4", "Prezime4");
Student a5 = new Student(5, "Ime5", "Prezime5");
batchOperation.InsertOrReplace(a1);
batchOperation.InsertOrReplace(a2);
batchOperation.InsertOrReplace(a3);
batchOperation.InsertOrReplace(a4);
batchOperation.InsertOrReplace(a5);
_table.ExecuteBatch(batchOperation);
}
public async static Task <int> ProcessEntities(DataTable dataTable, CloudTable table)
{
int batchCount = 0;
int totalRows = dataTable.Rows.Count - 1;
int returnTotalRows = totalRows;
_operations = new TableBatchOperation();
foreach (DataRow row in dataTable.Rows.Cast <DataRow>().Skip(1))
{
totalRows--;
batchCount++;
if (IsBatchCountExecutable(batchCount))
{
await ExecuteBatch(table);
batchCount = 0;
Console.WriteLine($"processed {_batchLimit} - " + Environment.NewLine + $"{totalRows}");
}
try
{
TableEntity entity = new TableEntity();
switch (table.Name)
{
case "Cities":
entity = GetCity(row);
break;
case "Schools":
entity = GetSchool(row);
break;
case "Statutes":
entity = GetStatute(row);
break;
case "Beats":
entity = GetBeat(row);
break;
default:
break;
}
DeduplicateBatch(entity);
_operations.InsertOrReplace(entity);
}
catch (Exception ex)
{
_log.LogError(ex.Message);
}
}
await ExecuteBatch(table);
return(returnTotalRows);
}
public static async Task <IActionResult> SeedDatabase(
[HttpTrigger(AuthorizationLevel.Anonymous, Global.HttpVerbGet, Route = null)] HttpRequest req,
[Table(Global.UserTableName, Connection = Global.AzureWebJobsStorage)] CloudTable userCloudTable,
ILogger log)
{
var userItems = new List <UserItem>();
TableContinuationToken continuationToken = null;
var entities = await userCloudTable.ExecuteQuerySegmentedAsync <UserEntity>(new TableQuery <UserEntity>(), continuationToken);
if (entities.Results.Count > 0)
{
foreach (var userEntity in entities.Results)
{
userItems.Add(userEntity.ToUserItem());
log.LogInformation(String.Format(GlobalMessages.UserAlreadyInDatabaseFormat, userEntity.UserName));
}
return(new OkObjectResult(userItems));
}
// database is empty - now seed it, this simulates a live system with users.
var userA = MakeUserEntity("John", "john", "56bc6a96-d6dc-406e-b36f-46373936c3bd");
var userB = MakeUserEntity("Sue", "sue", "8f9b0fa5-4afe-4120-9e99-4f32148a79fc");
var userC = MakeUserEntity("Tim", "tim", "197f8915-a37f-41d0-97da-5514d85966b5");
var batchOperation = new TableBatchOperation();
batchOperation.InsertOrReplace(userA);
batchOperation.InsertOrReplace(userB);
batchOperation.InsertOrReplace(userC);
var results = await userCloudTable.ExecuteBatchAsync(batchOperation);
foreach (var result in results)
{
if (result.Result is UserEntity userEntity)
{
userItems.Add(userEntity.ToUserItem());
log.LogInformation(String.Format(GlobalMessages.UserAddedToDatabaseFormat, userEntity.UserName));
}
}
return(new OkObjectResult(userItems));
}
protected override async Task PushToTargetAsync(IEnumerable <ResourceUsageRecord> records, Guid batchId, CancellationToken cancellationToken)
{
try
{
var batchOperation = new TableBatchOperation();
foreach (var record in records)
{
// Fill in record with Tenant info
var tenant = await TenantCacheClient.GetTenantAsync(record.EngagementAccount);
if (tenant == null)
{
BillingEventSource.Current.Warning(BillingEventSource.EmptyTrackingId, this, nameof(this.PushToTargetAsync), OperationStates.FailedMatch, $"Unable to get tenant for account '{record.EngagementAccount}'");
}
else if (this.pushUsageForWhitelistedSubscriptionsOnly)
{
if (Guid.TryParse(tenant.SubscriptionId, out Guid subId) && this.whitelistedSubscriptionIds.Contains(subId))
{
batchOperation.InsertOrReplace(new UsageRecord(record, tenant, batchId));
}
else
{
BillingEventSource.Current.Info(BillingEventSource.EmptyTrackingId, this, nameof(this.PushToTargetAsync), OperationStates.Dropped, $"Drop usage for subscription '{tenant.SubscriptionId}' as it's not in whitelist");
}
}
else
{
batchOperation.InsertOrReplace(new UsageRecord(record, tenant, batchId));
}
}
if (batchOperation.Count > 0)
{
var results = await this.table.ExecuteBatchAsync(batchOperation, cancellationToken);
BillingEventSource.Current.Info(BillingEventSource.EmptyTrackingId, this, nameof(this.PushToTargetAsync), OperationStates.Succeeded, $"Push usage with PartitionId = {batchId}, count = {records.Count()}");
}
}
catch (Exception ex)
{
BillingEventSource.Current.ErrorException(BillingEventSource.EmptyTrackingId, this, nameof(this.PushToTargetAsync), OperationStates.Failed, string.Empty, ex);
throw ex;
}
}
public async Task UpdateWaterMarkedRender(List <WaterMarkedRender> renderList)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var render in renderList)
{
batchOperation.InsertOrReplace(new UnifiedResponse.TWaterMarkedRender(render));
}
await _WaterMarkRenderTable.ExecuteBatchAsync(batchOperation);
}
public static void SaveToStorage(IEnumerable <TemplateModel> templates)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (TemplateModel template in templates)
{
batchOperation.InsertOrReplace(template);
}
StorageFactory.Instance.IpcAzureAppTenantStateTable.ExecuteBatch(batchOperation, tableReqOptions);
}
private void PersistQueryTable(IEnumerable <TwitterSearchRow> queries)
{
var batchOperation = new TableBatchOperation();
foreach (var query in queries)
{
batchOperation.InsertOrReplace(query);
}
MetadataTable.ExecuteBatch(batchOperation);
}
public void BatchInsertObjectIntoTable(params TableEntity[] objs)
{
var batchOperation = new TableBatchOperation();
foreach (TableEntity ent in objs)
{
batchOperation.InsertOrReplace(ent);
}
_table.ExecuteBatch(batchOperation);
}
public static void Run([TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, TraceWriter log)
{
log.Info($"C# Timer trigger function executed at: {DateTime.Now}");
List <string> contactList;
TableBatchOperation batchOperationObj;
UserEntity userEntityObj;
int UserIncrementCounter = 0;
try
{
//Getting Mock List Data
contactList = GetMockContactnumbers();
//Authenticating Table and creating Table instance
CloudTable cloudTable = AuthTable();
//Creating Batches of 100 items in order to insert them into AzureStorage
var batches = contactList.Batch(100);
log.Info($"Batch Job Started : {DateTime.Now}");
#region BATCH JOB
//Iterating through each batch
foreach (var batch in batches)
{
batchOperationObj = new TableBatchOperation();
//Iterating through each batch entities
foreach (var item in batch)
{
userEntityObj = new UserEntity("HR Department", "rowKey");
{
UserIncrementCounter++;
userEntityObj.PartitionKey = "HR Department";
userEntityObj.RowKey = "User" + UserIncrementCounter.ToString();
userEntityObj.ContactNumber = item;
}
batchOperationObj.InsertOrReplace(userEntityObj);
}
cloudTable.ExecuteBatch(batchOperationObj);
}
#endregion BATCH JOB
log.Info($"Batch Job Completed : {DateTime.Now}");
}
catch (Exception e)
{
throw e;
}
}
private void FillBookstore()
{
TableBatchOperation operations = new TableBatchOperation();
Book b1 = new Book("001");
b1.Name = "Na drini cuprija";
b1.Price = new Random().Next(500, 1000);
b1.Count = new Random().Next(10);
Book b2 = new Book("002");
b2.Name = "Besnilo";
b2.Price = new Random().Next(500, 1000);
b2.Count = new Random().Next(10);
Book b3 = new Book("003");
b3.Name = "Lovac u zitu";
b3.Price = new Random().Next(500, 1000);
b3.Count = new Random().Next(10);
Book b4 = new Book("004");
b4.Name = "Alhemicar";
b4.Price = new Random().Next(500, 1000);
b4.Count = new Random().Next(10);
Book b5 = new Book("005");
b5.Name = "Ja,Aleks Kros";
b5.Price = new Random().Next(500, 1000);
b5.Count = new Random().Next(10);
operations.InsertOrReplace(b1);
operations.InsertOrReplace(b2);
operations.InsertOrReplace(b3);
operations.InsertOrReplace(b4);
operations.InsertOrReplace(b5);
_table.ExecuteBatch(operations);
}
public void SaveLeaves(List <Leaf> leaves)
{
var batchOp = new TableBatchOperation();
foreach (Leaf leaf in leaves)
{
batchOp.InsertOrReplace(leaf);
}
var result = table.ExecuteBatch(batchOp);
}
/// <summary>
/// Create or update an entity in the table storage.
/// </summary>
/// <param name="entities">Entities to be created or updated.</param>
/// <returns>A task that represents the work queued to execute.</returns>
protected virtual async Task CreateOrUpdateBatchAsync(List <T> entities)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var entity in entities)
{
batchOperation.InsertOrReplace(entity);
}
await this.Table.ExecuteBatchAsync(batchOperation).ConfigureAwait(true);
}
public async Task StoreAsync <T>(nStoreOperation storageOperationType, IEnumerable <T> models) where T : new()
{
try
{
// Retrieve a reference to the table.
CloudTable table = GetTableReference(GetTableName <T>());
// Create the batch operation.
TableBatchOperation batchOperation = new TableBatchOperation();
// lookup the entitymapper
var entityMapper = _entityMapperRegistry[typeof(T)];
// Add all items
foreach (var model in models)
{
switch (storageOperationType)
{
case nStoreOperation.insertOperation:
batchOperation.Insert(new DynamicTableEntity <T>(model, entityMapper));
break;
case nStoreOperation.insertOrReplaceOperation:
batchOperation.InsertOrReplace(new DynamicTableEntity <T>(model, entityMapper));
break;
case nStoreOperation.mergeOperation:
batchOperation.Merge(new DynamicTableEntity <T>(model, entityMapper));
break;
case nStoreOperation.mergeOrInserOperation:
batchOperation.InsertOrMerge(new DynamicTableEntity <T>(model, entityMapper));
break;
}
}
// execute
await table.ExecuteBatchAsync(batchOperation);
}
catch (StorageException ex)
{
// check the exception
if (!_autoCreateTable || !ex.Message.StartsWith("0:The table specified does not exist", StringComparison.CurrentCulture))
{
throw ex;
}
// try to create the table
await CreateTableAsync <T>();
// retry
await StoreAsync <T>(storageOperationType, models);
}
}
/// <summary>
/// This Function will insert entity
/// </summary>
/// <returns></returns>
public async static Task <bool> InsertEntityInBatch(CloudTable cloudTable)
{
Employee employee1 = new Employee("Training", Guid.NewGuid().ToString())
{
Email = "*****@*****.**", PhoneNumber = 123
};
Employee employee2 = new Employee("Training", Guid.NewGuid().ToString())
{
Email = "*****@*****.**", PhoneNumber = 123
};
TableBatchOperation tablebatchOperations = new TableBatchOperation();
tablebatchOperations.InsertOrReplace(employee1);
tablebatchOperations.InsertOrReplace(employee2);
await cloudTable.ExecuteBatchAsync(tablebatchOperations);
return(true);
}
/// <summary>1. Get the List of scale sets for the resource group.
/// 2. Get all the virtual machines from the each scale set and them into batch operation
/// 3. Combine all the tasks and return the list of tasks.</summary>
/// <param name="virtualMachineScaleSets">List of scale sets for the resource group</param>
/// <param name="batchTasks"></param>
/// <param name="virtualMachineCloudTable">Get the virtual machine table instance</param>
/// <param name="virtualMachineScaleSetCloudTable">Get the scale set table instance</param>
/// <param name="log">Trace writer instance</param>
/// <returns></returns>
private static void GetVirtualMachineAndLoadBalancerBatch(IEnumerable <ILoadBalancer> loadBalancers,
ConcurrentBag <Task> batchTasks, CloudTable virtualMachineCloudTable,
CloudTable loadBalancerCloudTable, AzureClient azureClient, TraceWriter log)
{
if (loadBalancers == null || virtualMachineCloudTable == null || loadBalancerCloudTable == null)
{
return;
}
var listOfLoadBalancerEntities = new ConcurrentBag <LoadBalancerCrawlerResponse>();
// get the batch operation for all the load balancers and corresponding virtual machine instances
//foreach (var eachLoadBalancer in loadBalancers)
Parallel.ForEach(loadBalancers, eachLoadBalancer =>
{
try
{
listOfLoadBalancerEntities.Add(ConvertToLoadBalancerCrawlerResponse(eachLoadBalancer, azureClient, log));
var loadBalancersVirtualMachines = GetVirtualMachinesFromLoadBalancers(eachLoadBalancer.ResourceGroupName, eachLoadBalancer.Id, azureClient, log);
var tasks = new List <Task>
{
loadBalancersVirtualMachines
};
Task.WhenAll(tasks);
var virtualMachineIds = loadBalancersVirtualMachines.Result;
var virtualMachinesBatchOperation = InsertLoadBalancerVirtualMachines(virtualMachineIds, eachLoadBalancer, azureClient, log);
if (virtualMachinesBatchOperation != null && virtualMachinesBatchOperation.Count > 0)
{
batchTasks.Add(virtualMachineCloudTable.ExecuteBatchAsync(virtualMachinesBatchOperation));
}
var virtualMachinesList = new List <string>();
}
catch (Exception e)
{
// catch the error, to continue adding other entities to table
log.Error($"timercrawlerforvirtualmachinescaleset threw the exception ", e,
"GetVirtualMachineAndScaleSetBatch for the scale set: " + eachLoadBalancer.Name);
}
});
// table batch operation currently allows only 100 per batch, So ensuring the one batch operation will have only 100 items
for (var i = 0; i < listOfLoadBalancerEntities.Count; i += TableConstants.TableServiceBatchMaximumOperations)
{
var batchItems = listOfLoadBalancerEntities.Skip(i)
.Take(TableConstants.TableServiceBatchMaximumOperations).ToList();
var loadBalancerTableBatchOperation = new TableBatchOperation();
foreach (var entity in batchItems)
{
loadBalancerTableBatchOperation.InsertOrReplace(entity);
}
batchTasks.Add(loadBalancerCloudTable.ExecuteBatchAsync(loadBalancerTableBatchOperation));
}
}
public void TableBatchAllSupportedOperationsSync()
{
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
// insert
batch.Insert(GenerateRandomEnitity(pk));
// delete
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Delete(entity);
}
// replace
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Replace(entity);
}
// insert or replace
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.InsertOrReplace(entity);
}
// merge
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Merge(entity);
}
// insert or merge
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.InsertOrMerge(entity);
}
IList <TableResult> results = this.repTable.ExecuteBatch(batch);
Assert.AreEqual(results.Count, 6);
IEnumerator <TableResult> enumerator = results.GetEnumerator();
for (int i = 0; i < results.Count; i++)
{
enumerator.MoveNext();
Assert.AreEqual((int)HttpStatusCode.NoContent, enumerator.Current.HttpStatusCode, "HttpStatusCode mismatch i={0}", i);
}
}
public async Task AddOrUpdateAsync(IEnumerable <T> objs)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var obj in objs)
{
batchOperation.InsertOrReplace(obj);
}
await table.ExecuteBatchAsync(batchOperation).ConfigureAwait(false);
}
public static Task InsertOrMergeAll(this CloudTable table, IEnumerable <TableEntity> entities)
{
var batchOp = new TableBatchOperation();
foreach (var entity in entities)
{
batchOp.InsertOrReplace(entity);
}
return(table.ExecuteBatchAsync(batchOp));
}
// All must have the same partition key
public async Task WriteBatchAsync(T[] entities, TableInsertMode mode = TableInsertMode.Insert)
{
if (entities.Length == 0)
{
return; // nothing to write.
}
string partitionKey = entities[0].PartitionKey;
const int BatchSize = 99;
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var entity in entities)
{
if (entity.PartitionKey != partitionKey)
{
throw new InvalidOperationException("All entities in a batch must have same partition key");
}
ValidateRowKey(entity.RowKey);
switch (mode)
{
case TableInsertMode.Insert:
batchOperation.Insert(entity);
break;
case TableInsertMode.InsertOrMerge:
batchOperation.InsertOrMerge(entity);
break;
case TableInsertMode.InsertOrReplace:
batchOperation.InsertOrReplace(entity);
break;
default:
throw new InvalidOperationException("Unsupported insert mode: " + mode.ToString());
}
if (batchOperation.Count == BatchSize)
{
// Flush
await _table.ExecuteBatchAsync(batchOperation);
batchOperation = new TableBatchOperation();
}
}
if (batchOperation.Count > 0)
{
await _table.ExecuteBatchAsync(batchOperation);
}
}
private TableBatchOperation BuildBatch <T>(IEnumerable <T> records, string partition, bool isDelete = false)
{
TableBatchOperation batch = new TableBatchOperation();
foreach (var record in records)
{
if (record is ITableEntity)
{
if (string.IsNullOrEmpty((record as ITableEntity).PartitionKey))
{
(record as ITableEntity).PartitionKey = partition;
if (isDelete)
{
(record as ITableEntity).ETag = "*";
}
}
if (!isDelete)
{
batch.InsertOrReplace((ITableEntity)record);
}
if (isDelete)
{
batch.Delete((ITableEntity)record);
}
}
else
{
var obj = BuildTableEntity(record);
if (!isDelete)
{
batch.InsertOrReplace((ITableEntity)obj);
}
if (isDelete)
{
batch.Delete((ITableEntity)obj);
}
}
}
return(batch);
}
private IList <AcceptedUserComment> addComments(string type, int dddEventId, DDDEventDetail eventDetail, string userName, string userToken, string clientToken, IList <UserComment> userComments)
{
if (userComments == null || userComments.Count == 0)
{
return(null);
}
var eventScoreService = LazyLoadEventScoreService(userToken, userName, dddEventId);
var token = userToken ?? clientToken;
var comments = userComments.Select(x => new Comment
{
PartitionKey = dddEventId.ToString(),
RowKey = type + token + "_" + x.id + "",
SessionId = x.sessionId,
Type = type,
UserName = userName,
UserToken = userToken,
ClientToken = clientToken,
UserComment = x.comment,
Date = x.date
});
foreach (var comment in userComments)
{
if (comment.sessionId != null)
{
var session = eventDetail.Sessions.First(x => x.Id == comment.sessionId);
eventScoreService.AddCommentItem(type, session.TimeSlotId);
}
else
{
eventScoreService.AddCommentItem(type, null);
}
}
TableBatchOperation batch = new TableBatchOperation();
foreach (var comment in comments)
{
batch.InsertOrReplace(comment);
}
userCommentsTable.ExecuteBatch(batch);
var accepted = userComments.Select(x => new AcceptedUserComment
{
eventId = dddEventId,
id = x.id,
sessionId = x.sessionId
});
return(accepted.ToList());
}
private void addOrUpdateSessionData(int dddEventId, DDDEventDetail eventDetail, string userName, string userToken, string clientToken, IList <PocketDDD.Models.UserSessionData> sessionData)
{
if (sessionData == null || sessionData.Count() == 0)
{
return;
}
var eventScoreService = LazyLoadEventScoreService(userToken, userName, dddEventId);
var token = userToken ?? clientToken;
var userSessionDatas = sessionData.Select(x => new PocketDDD.Models.Azure.UserSessionData
{
PartitionKey = dddEventId.ToString(),
RowKey = x.sessionId.ToString() + "_" + token,
SessionId = x.sessionId,
UserName = userName,
UserToken = userToken,
ClientToken = clientToken,
Bookmarked = x.bookmarked,
AttendingStatus = x.attendingStatus,
SpeakerKnowledgeRating = x.speakerKnowledgeRating,
SpeakerSkillsRating = x.speakerSkillsRating
});
foreach (var sessionDataItem in sessionData)
{
var session = eventDetail.Sessions.First(x => x.Id == sessionDataItem.sessionId);
if (sessionDataItem.bookmarked || sessionDataItem.attendingStatus != 2)
{
eventScoreService.AddBookmarkOrAttendingItem(session.TimeSlotId);
}
if (sessionDataItem.speakerKnowledgeRating != null)
{
eventScoreService.AddKnowledgeRatingItem(session.TimeSlotId);
}
if (sessionDataItem.speakerSkillsRating != null)
{
eventScoreService.AddSkillRatingItem(session.TimeSlotId);
}
}
TableBatchOperation batch = new TableBatchOperation();
foreach (var userSessionData in userSessionDatas)
{
batch.InsertOrReplace(userSessionData);
}
userSessionDataTable.ExecuteBatch(batch);
}
public void InsertOrReplaceBatch(IEnumerable <T> objs)
{
List <List <T> > chunks = GetChunks(objs);
foreach (var chunk in chunks)
{
var batchOperation = new TableBatchOperation();
foreach (var obj in chunk)
{
batchOperation.InsertOrReplace(obj);
}
Table.ExecuteBatch(batchOperation);
}
}
public void UpdatePlayers(IEnumerable <PlayerEntity> players)
{
var tableClient = GetClient();
CloudTable table = tableClient.GetTableReference("players");
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var player in players)
{
batchOperation.InsertOrReplace(player);
}
table.ExecuteBatch(batchOperation);
}
static TableBatchOperation SaveBootstrap(IEnumerable<SearchModel> searchModel)
{
var batchOperation = new TableBatchOperation();
foreach (var model in searchModel)
{
if (string.IsNullOrWhiteSpace(model.Url) || string.IsNullOrWhiteSpace(model.PartitionKey))
{
throw new InvalidOperationException("We require a partition key, and row key");
}
batchOperation.InsertOrReplace(model);
}
return batchOperation;
}
public IList <TableResult> UpsertEntities(string tableName, IList <StorageEntity> entities)
{
SetProperties(entities);
CloudTable table = _storage.GetTableReference(tableName);
table.CreateIfNotExists();
TableBatchOperation operation = new TableBatchOperation();
foreach (StorageEntity entity in entities)
{
operation.InsertOrReplace(entity);
}
return(table.ExecuteBatch(operation));
}
public void Load()
{
TableBatchManager.LogInfo("Load batch called");
try
{
TableBatchOperation op = new TableBatchOperation();
foreach (var e in Entities)
{
if (Merge)
op.InsertOrMerge(e);
else
op.InsertOrReplace(e);
}
Table.ExecuteBatch(op);
TableBatchManager.LogInfo("exec batch");
}
catch(Exception ex)
{
TableBatchManager.LogError("Error: " + ex);
}
}
public static void ProcessPlayerGame(Int64 playerId, PlayerGameData gameData, Guid gameId, Int64 gameSeconds)
{
// Create the batch operation.
TableBatchOperation batchOperation = new TableBatchOperation();
//TODO: Get Player Row
PlayerEntity player = PlayerEntity.GetPlayerEntity(playerId);
batchOperation.InsertOrReplace(player);
//Update Player Entity with Game Data
player.TotalDeaths += gameData.Deaths;
player.TotalKills += gameData.Kills;
player.TotalPoints += gameData.Points;
player.TotalWins += gameData.Win ? 1 : 0;
player.TotalGames += 1;
player.TotalSecondsPlayed += gameSeconds;
//Create PlayerGame Row
PlayerGameEntity playerGame = new PlayerGameEntity(playerId, gameId)
{
Points = gameData.Points,
Win = gameData.Win,
Kills = gameData.Kills,
Deaths = gameData.Deaths,
GameDuration = gameSeconds
};
batchOperation.Insert(playerGame);
try
{
StorageManager.Instance.PlayersTable.ExecuteBatch(batchOperation);
}
catch (Exception ex)
{
//TODO: handle exception, check if its because an entity already existed.
//This means we've already handled this data.
}
}
public async Task<bool> AddSubscriptions(IEnumerable<UserSubscription> subscriptionsToAdd)
{
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable userSubscriptionsTable =
tableClient.GetTableReference("userSubscriptions");
var tableExists = await userSubscriptionsTable.ExistsAsync();
if (!tableExists)
{
await userSubscriptionsTable.CreateIfNotExistsAsync();
}
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var subscription in subscriptionsToAdd)
{
UserSubscriptionEntity userSubscriptionEntity =
new UserSubscriptionEntity(subscription.UserId, subscription.FriendId);
batchOperation.InsertOrReplace(userSubscriptionEntity);
}
await userSubscriptionsTable.ExecuteBatchAsync(batchOperation);
return true;
}
public int CommitChanges()
{
if (string.IsNullOrEmpty(this.token))
return 0;
if(ScoreItems.Count > 0)
{
TableBatchOperation batch = new TableBatchOperation();
ScoreItems.ToList().ForEach(x =>
{
batch.InsertOrReplace(x.Value);
});
eventScoreTable.ExecuteBatch(batch);
}
TableQuery<EventScoreItem> query = new TableQuery<EventScoreItem>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, this.token));
var eventScore = eventScoreTable.ExecuteQuery(query).Sum(x=>x.Score);
var totalItem = new EventScoreItem
{
PartitionKey = dddEventId.ToString(),
RowKey = this.token,
DDDEventId = dddEventId,
UserName = userName,
Score = eventScore
};
TableOperation insert = TableOperation.InsertOrReplace(totalItem);
eventScoreTable.Execute(insert);
return eventScore;
}
private IList<AcceptedUserComment> addComments(string type, int dddEventId, DDDEventDetail eventDetail, string userName, string userToken, string clientToken, IList<UserComment> userComments)
{
if (userComments == null || userComments.Count == 0)
return null;
var eventScoreService = LazyLoadEventScoreService(userToken, userName, dddEventId);
var token = userToken ?? clientToken;
var comments = userComments.Select(x => new Comment
{
PartitionKey = dddEventId.ToString(),
RowKey = type + token + "_" + x.id + "",
SessionId = x.sessionId,
Type = type,
UserName = userName,
UserToken = userToken,
ClientToken = clientToken,
UserComment = x.comment,
Date = x.date
});
foreach (var comment in userComments)
{
if (comment.sessionId != null)
{
var session = eventDetail.Sessions.First(x => x.Id == comment.sessionId);
eventScoreService.AddCommentItem(type, session.TimeSlotId);
}
else
{
eventScoreService.AddCommentItem(type, null);
}
}
TableBatchOperation batch = new TableBatchOperation();
foreach (var comment in comments)
{
batch.InsertOrReplace(comment);
}
userCommentsTable.ExecuteBatch(batch);
var accepted = userComments.Select(x => new AcceptedUserComment
{
eventId = dddEventId,
id = x.id,
sessionId = x.sessionId
});
return accepted.ToList();
}
public void TableBatchAllSupportedOperationsSync()
{
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
// insert
batch.Insert(GenerateRandomEnitity(pk));
// delete
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Delete(entity);
}
// replace
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Replace(entity);
}
// insert or replace
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.InsertOrReplace(entity);
}
// merge
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.Merge(entity);
}
// insert or merge
{
DynamicReplicatedTableEntity entity = GenerateRandomEnitity(pk);
this.repTable.Execute(TableOperation.Insert(entity));
batch.InsertOrMerge(entity);
}
IList<TableResult> results = this.repTable.ExecuteBatch(batch);
Assert.AreEqual(results.Count, 6);
IEnumerator<TableResult> enumerator = results.GetEnumerator();
for (int i = 0; i < results.Count; i++)
{
enumerator.MoveNext();
Assert.AreEqual((int)HttpStatusCode.NoContent, enumerator.Current.HttpStatusCode, "HttpStatusCode mismatch i={0}", i);
}
}
public async Task Append(string eventStreamId, string transactionId, int expectedVersion, IEnumerable<IAggregateEvent<JObject>> events)
{
var table = this.client.GetTableReference(this.tableName);
await EnsureTableExists(table);
// no need to validate expected version, because the batch transaction will fail if a duplicate exists
var transaction = new TableBatchOperation();
transaction.InsertOrReplace(CreateSourceRoot(eventStreamId, expectedVersion + events.Count()));
foreach (var ev in events)
{
transaction.Insert(ev.ToEntity());
}
transaction.Insert(CreateUncommittedLog(eventStreamId, transactionId, events.Select(ev => ev.SequenceId)));
try
{
var results = await table.ExecuteBatchAsync(transaction);
return;
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode != (int)HttpStatusCode.Conflict)
{
throw; // different error, rethrow
}
}
// conflict
var sourceRootVersion = await GetSourceRootVersion(table, eventStreamId);
throw new ConcurrencyException(eventStreamId, expectedVersion, sourceRootVersion);
}
private async Task SaveInfo()
{
CloudTable metatable = _dstClient.GetTableReference(MetatableName);
Console.WriteLine("new destination status");
var op = new TableBatchOperation();
foreach (var batch in _timestamps.OrderBy(x => x.Key.Name).Batch(100))
{
foreach (var item in batch)
{
var entity = new DynamicTableEntity("SyncTimestamps", item.Key.Name);
entity.Properties["SourceTimestamp"] = new EntityProperty(item.Value);
op.InsertOrReplace(entity);
Console.WriteLine("{0,-40}{1}", item.Key.Name, item.Value);
}
await metatable.ExecuteBatchAsync(op, _token);
}
}
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);
}
public void TableBatchInsertOrReplaceAPM()
{
CloudTableClient tableClient = GenerateCloudTableClient();
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo");
insertOrReplaceEntity.Properties.Add("prop1", new EntityProperty("value1"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult asyncRes = null;
currentTable.BeginExecuteBatch(batch, (res) =>
{
asyncRes = res;
evt.Set();
}, null);
evt.WaitOne();
currentTable.EndExecuteBatch(asyncRes);
}
// Retrieve Entity & Verify Contents
TableResult result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
using (ManualResetEvent evt = new ManualResetEvent(false))
{
IAsyncResult asyncRes = null;
currentTable.BeginExecuteBatch(batch2, (res) =>
{
asyncRes = res;
evt.Set();
}, null);
evt.WaitOne();
currentTable.EndExecuteBatch(asyncRes);
}
// Retrieve Entity & Verify Contents
result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
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 TableBatchAllSupportedOperationsSync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
// insert
batch.Insert(GenerateRandomEnitity(pk));
// delete
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Delete(entity);
}
// replace
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Replace(entity);
}
// insert or replace
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.InsertOrReplace(entity);
}
// merge
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Merge(entity);
}
// insert or merge
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.InsertOrMerge(entity);
}
IList<TableResult> results = currentTable.ExecuteBatch(batch);
Assert.AreEqual(results.Count, 6);
IEnumerator<TableResult> enumerator = results.GetEnumerator();
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.Created);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
}
async Task DoRandomAtomicCalls()
{
for (int callNum = 0; callNum < MigrationModel.NUM_CALLS_PER_MACHINE; callNum++)
{
SortedDictionary<PrimaryKey, DynamicTableEntity> dump = await peekProxy.DumpReferenceTableAsync();
if (PSharpRuntime.Nondeterministic())
{
// Query
var query = new TableQuery<DynamicTableEntity>();
query.FilterString = ChainTableUtils.CombineFilters(
TableQuery.GenerateFilterCondition(
TableConstants.PartitionKey, QueryComparisons.Equal, MigrationModel.SINGLE_PARTITION_KEY),
TableOperators.And,
NondeterministicUserPropertyFilterString());
await RunQueryAtomicAsync(query);
}
else
{
// Batch write
int batchSize = PSharpRuntime.Nondeterministic() ? 2 : 1;
var batch = new TableBatchOperation();
var rowKeyChoices = new List<string> { "0", "1", "2", "3", "4", "5" };
for (int opNum = 0; opNum < batchSize; opNum++)
{
int opTypeNum = PSharpNondeterminism.Choice(7);
int rowKeyI = PSharpNondeterminism.Choice(rowKeyChoices.Count);
string rowKey = rowKeyChoices[rowKeyI];
rowKeyChoices.RemoveAt(rowKeyI); // Avoid duplicate in same batch
var primaryKey = new PrimaryKey(MigrationModel.SINGLE_PARTITION_KEY, rowKey);
string eTag = null;
if (opTypeNum >= 1 && opTypeNum <= 3)
{
DynamicTableEntity existingEntity;
int etagTypeNum = PSharpNondeterminism.Choice(
dump.TryGetValue(primaryKey, out existingEntity) ? 3 : 2);
switch (etagTypeNum)
{
case 0: eTag = ChainTable2Constants.ETAG_ANY; break;
case 1: eTag = "wrong"; break;
case 2: eTag = existingEntity.ETag; break;
}
}
DynamicTableEntity entity = new DynamicTableEntity
{
PartitionKey = MigrationModel.SINGLE_PARTITION_KEY,
RowKey = rowKey,
ETag = eTag,
Properties = new Dictionary<string, EntityProperty> {
// Give us something to see on merge. Might help with tracing too!
{ string.Format("{0}_c{1}_o{2}", machineId.ToString(), callNum, opNum),
new EntityProperty(true) },
// Property with 50%/50% distribution for use in filters.
{ "isHappy", new EntityProperty(PSharpRuntime.Nondeterministic()) }
}
};
switch (opTypeNum)
{
case 0: batch.Insert(entity); break;
case 1: batch.Replace(entity); break;
case 2: batch.Merge(entity); break;
case 3: batch.Delete(entity); break;
case 4: batch.InsertOrReplace(entity); break;
case 5: batch.InsertOrMerge(entity); break;
case 6:
entity.ETag = ChainTable2Constants.ETAG_DELETE_IF_EXISTS;
batch.Delete(entity); break;
}
}
await RunBatchAsync(batch);
}
}
}
async Task LoadDefaultDataAsync()
{
#if false
MTableEntity eMeta = new MTableEntity {
PartitionKey = MigrationModel.SINGLE_PARTITION_KEY,
RowKey = MigratingTable.ROW_KEY_PARTITION_META,
partitionState = MTablePartitionState.SWITCHED,
};
MTableEntity e0 = TestUtils.CreateTestMTableEntity("0", "orange");
MTableEntity e1old = TestUtils.CreateTestMTableEntity("1", "red");
MTableEntity e2new = TestUtils.CreateTestMTableEntity("2", "green");
MTableEntity e3old = TestUtils.CreateTestMTableEntity("3", "blue");
MTableEntity e3new = TestUtils.CreateTestMTableEntity("3", "azure");
MTableEntity e4old = TestUtils.CreateTestMTableEntity("4", "yellow");
MTableEntity e4new = TestUtils.CreateTestMTableEntity("4", null, true);
var oldBatch = new TableBatchOperation();
oldBatch.InsertOrReplace(eMeta);
oldBatch.InsertOrReplace(e0);
oldBatch.InsertOrReplace(e1old);
oldBatch.InsertOrReplace(e3old);
oldBatch.InsertOrReplace(e4old);
IList<TableResult> oldTableResult = await oldTable.ExecuteBatchAsync(oldBatch);
await ExecuteExportedMirrorBatchAsync(oldBatch, oldTableResult);
var newBatch = new TableBatchOperation();
newBatch.InsertOrReplace(e0);
newBatch.InsertOrReplace(e2new);
newBatch.InsertOrReplace(e3new);
newBatch.InsertOrReplace(e4new);
IList<TableResult> newTableResult = await newTable.ExecuteBatchAsync(newBatch);
// Allow rows to overwrite rather than composing the virtual ETags manually.
// InsertOrReplace doesn't use the ETag, so we don't care that the ETag was mutated by the original batch.
await ExecuteExportedMirrorBatchAsync(newBatch, newTableResult);
#endif
// Start with the old table now.
var batch = new TableBatchOperation();
batch.InsertOrReplace(TestUtils.CreateTestEntity2("0", true));
batch.InsertOrReplace(TestUtils.CreateTestEntity2("1", false));
batch.InsertOrReplace(TestUtils.CreateTestEntity2("3", false));
batch.InsertOrReplace(TestUtils.CreateTestEntity2("4", true));
IList<TableResult> oldTableResult = await oldTable.ExecuteBatchAsync(batch);
// InsertOrReplace doesn't use the ETag, so we don't care that the ETag was mutated by the original batch.
await referenceTable.ExecuteMirrorBatchAsync(batch, oldTableResult);
}
public void TableBatchAllSupportedOperationsAPM()
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
// insert
batch.Insert(GenerateRandomEnitity(pk));
// delete
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Delete(entity);
}
// replace
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Replace(entity);
}
// insert or replace
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.InsertOrReplace(entity);
}
// merge
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.Merge(entity);
}
// insert or merge
{
DynamicTableEntity entity = GenerateRandomEnitity(pk);
currentTable.Execute(TableOperation.Insert(entity));
batch.InsertOrMerge(entity);
}
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, 6);
IEnumerator<TableResult> enumerator = results.GetEnumerator();
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.Created);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
}
private void addOrUpdateSessionData(int dddEventId, DDDEventDetail eventDetail, string userName, string userToken, string clientToken, IList<PocketDDD.Models.UserSessionData> sessionData)
{
if (sessionData == null || sessionData.Count() == 0)
return;
var eventScoreService = LazyLoadEventScoreService(userToken, userName, dddEventId);
var token = userToken ?? clientToken;
var userSessionDatas = sessionData.Select(x => new PocketDDD.Models.Azure.UserSessionData
{
PartitionKey = dddEventId.ToString(),
RowKey = x.sessionId.ToString() + "_" + token,
SessionId = x.sessionId,
UserName = userName,
UserToken = userToken,
ClientToken = clientToken,
Bookmarked = x.bookmarked,
AttendingStatus = x.attendingStatus,
SpeakerKnowledgeRating = x.speakerKnowledgeRating,
SpeakerSkillsRating = x.speakerSkillsRating
});
foreach (var sessionDataItem in sessionData)
{
var session = eventDetail.Sessions.First(x => x.Id == sessionDataItem.sessionId);
if (sessionDataItem.bookmarked || sessionDataItem.attendingStatus != 2)
eventScoreService.AddBookmarkOrAttendingItem(session.TimeSlotId);
if(sessionDataItem.speakerKnowledgeRating != null)
eventScoreService.AddKnowledgeRatingItem(session.TimeSlotId);
if (sessionDataItem.speakerSkillsRating != null)
eventScoreService.AddSkillRatingItem(session.TimeSlotId);
}
TableBatchOperation batch = new TableBatchOperation();
foreach (var userSessionData in userSessionDatas)
{
batch.InsertOrReplace(userSessionData);
}
userSessionDataTable.ExecuteBatch(batch);
}
public void TableBatchInsertOrReplaceSync()
{
CloudTableClient tableClient = GenerateCloudTableClient();
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo");
insertOrReplaceEntity.Properties.Add("prop1", new EntityProperty("value1"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
currentTable.ExecuteBatch(batch);
// Retrieve Entity & Verify Contents
TableResult result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
currentTable.ExecuteBatch(batch2);
// Retrieve Entity & Verify Contents
result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private void DoTableBatchInsertOrReplaceEncryption(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;
}
};
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo" + format.ToString());
insertOrReplaceEntity.Properties.Add("A", new EntityProperty("a"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
currentTable.ExecuteBatch(batch, options);
// Retrieve Entity & Verify Contents
// Create the resolver to be used for unwrapping.
DictionaryKeyResolver resolver = new DictionaryKeyResolver();
resolver.Add(aesKey);
TableRequestOptions retrieveOptions = new TableRequestOptions() { EncryptionPolicy = new TableEncryptionPolicy(null, resolver) };
TableResult result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey), retrieveOptions);
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("B", new EntityProperty("b"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
currentTable.ExecuteBatch(batch2, options);
// Retrieve Entity & Verify Contents
result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey), retrieveOptions);
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["B"], retrievedEntity.Properties["B"]);
}
private async Task DoTableBatchInsertOrReplaceAsync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo" + format.ToString());
insertOrReplaceEntity.Properties.Add("prop1", new EntityProperty("value1"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
await currentTable.ExecuteBatchAsync(batch);
// Retrieve Entity & Verify Contents
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
await currentTable.ExecuteBatchAsync(batch2);
// Retrieve Entity & Verify Contents
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private async Task SyncTableSince(CloudTable table, DateTimeOffset timestamp)
{
var query = new TableQuery<DynamicTableEntity>
{
FilterString = TableQuery.GenerateFilterConditionForDate("Timestamp", "gt", timestamp),
};
IList<DynamicTableEntity> allFuckingEntities = await table.ExecuteQueryAsync(
query, _token, list => Console.WriteLine("loaded {0} rows", list.Count));
CloudTable dstTable = _dstClient.GetTableReference(table.Name);
await dstTable.CreateIfNotExistsAsync();
int n = 0;
DateTimeOffset maxSourceTs = timestamp;
foreach (var batch1 in allFuckingEntities.GroupBy(x => x.PartitionKey))
{
if (_token.IsCancellationRequested)
return;
foreach (var batch2 in batch1.Batch(100))
{
if (_token.IsCancellationRequested)
return;
var op = new TableBatchOperation();
foreach (DynamicTableEntity entity in batch2)
{
op.InsertOrReplace(entity);
if (entity.Timestamp > maxSourceTs)
{
maxSourceTs = entity.Timestamp;
}
}
await dstTable.ExecuteBatchAsync(op, _token);
n += Math.Min(op.Count, 100);
Console.WriteLine("sent {0} rows", n);
}
}
_timestamps[table] = maxSourceTs;
}
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 Execute()
{
try
{
// Retrieve the storage account from the connection string.
CloudStorageAccount account;
if (CloudStorageAccount.TryParse(_connectionString, out account))
{
// Create the table client.
CloudTableClient client = account.CreateCloudTableClient();
// Create the table if it doesn't exist.
CloudTable table = client.GetTableReference("postalcodegb");
table.CreateIfNotExists();
// TO DO : relative path? ~ didnt work :(
using (var reader = new TextFieldParser(Path.Combine(_appDataFolder, "GB.txt")))
{
reader.TextFieldType = FieldType.Delimited;
reader.Delimiters = new string[] { "\t" };
string[] currentRow;
TableBatchOperation batchOp = new TableBatchOperation();
while (!reader.EndOfData)
{
while (batchOp.Count < 100)
{
currentRow = reader.ReadFields();
var postalCodeEntity = new PostalCodeEntity()
{
iso2 = currentRow[0],
postalCode = currentRow[1],
placeName = currentRow[2],
stateName = currentRow[3],
stateCode = currentRow[4],
countyName = currentRow[5],
countyCode = currentRow[6],
communityName = currentRow[7],
communityCode = currentRow[8],
latitude = string.IsNullOrEmpty(currentRow[9]) ? (float)0 : float.Parse(currentRow[9], CultureInfo.InvariantCulture.NumberFormat),
longitude = string.IsNullOrEmpty(currentRow[10]) ? (float)0 : float.Parse(currentRow[10], CultureInfo.InvariantCulture.NumberFormat),
accuracy = string.IsNullOrEmpty(currentRow[11]) ? (int)0 : int.Parse(currentRow[11], CultureInfo.InvariantCulture.NumberFormat)
};
batchOp.InsertOrReplace(postalCodeEntity);
}
table.ExecuteBatch(batchOp);
}
}
}
}
catch (Exception ex)
{
Log.Error(string.Format(CultureInfo.InvariantCulture, "Failed to load data into Azure Table Storage: {0}", ex.Message), ex);
}
}
private async Task DoTableBatchAllSupportedOperationsAsync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
TableBatchOperation batch = new TableBatchOperation();
string pk = Guid.NewGuid().ToString();
// insert
batch.Insert(GenerateRandomEntity(pk));
// delete
{
DynamicTableEntity entity = GenerateRandomEntity(pk);
await currentTable.ExecuteAsync(TableOperation.Insert(entity));
batch.Delete(entity);
}
// replace
{
DynamicTableEntity entity = GenerateRandomEntity(pk);
await currentTable.ExecuteAsync(TableOperation.Insert(entity));
batch.Replace(entity);
}
// insert or replace
{
DynamicTableEntity entity = GenerateRandomEntity(pk);
await currentTable.ExecuteAsync(TableOperation.Insert(entity));
batch.InsertOrReplace(entity);
}
// merge
{
DynamicTableEntity entity = GenerateRandomEntity(pk);
await currentTable.ExecuteAsync(TableOperation.Insert(entity));
batch.Merge(entity);
}
// insert or merge
{
DynamicTableEntity entity = GenerateRandomEntity(pk);
await currentTable.ExecuteAsync(TableOperation.Insert(entity));
batch.InsertOrMerge(entity);
}
IList<TableResult> results = await currentTable.ExecuteBatchAsync(batch);
Assert.AreEqual(results.Count, 6);
IEnumerator<TableResult> enumerator = results.GetEnumerator();
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.Created);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
enumerator.MoveNext();
Assert.AreEqual(enumerator.Current.HttpStatusCode, (int)HttpStatusCode.NoContent);
}
public static void SaveToStorage(IEnumerable<TemplateModel> templates)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (TemplateModel template in templates)
{
batchOperation.InsertOrReplace(template);
}
StorageFactory.Instance.IpcAzureAppTenantStateTable.ExecuteBatch(batchOperation, tableReqOptions);
}
public void BatchOperationExceptionWhenUsingSmallerViewId()
{
long currentViewId = 100;
long badViewId = currentViewId - 1;
this.UpdateConfiguration(replicas, 0, false, currentViewId);
string jobType = "jobType-BatchOperationExceptionWhenUsingSmallerViewId";
string jobId = "jobId-BatchOperationExceptionWhenUsingSmallerViewId";
int count = 3; // number of operations in the batch _rtable_Operation
List<TableOperationType> opTypes = new List<TableOperationType>()
{
TableOperationType.Replace,
TableOperationType.InsertOrReplace,
TableOperationType.Delete,
};
//
// Insert
//
string jobIdTemplate = jobId + "-{0}";
string messageTemplate = "message-{0}";
string updatedMessageTemplate = "updated-" + messageTemplate;
string partitionKey = string.Empty;
//
// Insert entities
//
for (int i = 0; i < count; i++)
{
SampleRTableEntity originalEntity = new SampleRTableEntity(
jobType,
string.Format(jobIdTemplate, i),
string.Format(messageTemplate, i));
this.repTable.Execute(TableOperation.Insert(originalEntity));
partitionKey = originalEntity.PartitionKey;
}
//
// Retrieve entities and use them to create batchOperation to Replace or Delete
//
IEnumerable<SampleRTableEntity> allEntities = this.rtableWrapper.GetAllRows(partitionKey);
TableBatchOperation batchOperation = new TableBatchOperation();
int m = 0;
foreach (SampleRTableEntity entity in allEntities)
{
Console.WriteLine("{0}", entity.ToString());
Console.WriteLine("---------------------------------------");
if (opTypes[m] == TableOperationType.Replace)
{
SampleRTableEntity replaceEntity = new SampleRTableEntity(
entity.JobType,
entity.JobId,
string.Format(updatedMessageTemplate, m))
{
ETag = entity._rtable_Version.ToString()
};
batchOperation.Replace(replaceEntity);
}
else if (opTypes[m] == TableOperationType.InsertOrReplace)
{
SampleRTableEntity replaceEntity = new SampleRTableEntity(
entity.JobType,
entity.JobId,
string.Format(updatedMessageTemplate, m))
{
ETag = entity._rtable_Version.ToString()
};
batchOperation.InsertOrReplace(replaceEntity);
}
else if (opTypes[m] == TableOperationType.Delete)
{
entity.ETag = entity._rtable_Version.ToString();
batchOperation.Delete(entity);
}
else
{
throw new ArgumentException(
string.Format("opType={0} is NOT supported", opTypes[m]),
"opType");
}
m++;
}
//
// Call ModifyConfigurationBlob to change the viewId of the wrapper to an older value
//
Console.WriteLine("Changing the viewId to badViewId {0}", badViewId);
this.UpdateConfiguration(replicas, 0, false, badViewId);
//
// Execute Batch _rtable_Operation with bad viewId
//
Console.WriteLine("\nCalling BatchOperation with badViewId...");
try
{
this.repTable.ExecuteBatch(batchOperation);
}
catch (ReplicatedTableStaleViewException ex)
{
Console.WriteLine("Get this RTableStaleViewException: {0}", ex.Message);
Assert.IsTrue(ex.Message.Contains(string.Format("current _rtable_ViewId {0} is smaller than", badViewId)), "Got unexpected exception message");
}
}
private void PersistQueryTable(IEnumerable<TwitterSearchRow> queries)
{
var batchOperation = new TableBatchOperation();
foreach(var query in queries)
{
batchOperation.InsertOrReplace(query);
}
MetadataTable.ExecuteBatch(batchOperation);
}
public void Execute(TableBatchOperation batchOperation, TableEntity entity)
{
batchOperation.InsertOrReplace(entity);
}
/// <summary>
/// Insert a batch of ElevationDataSetTableEntity into the storage table
/// </summary>
/// <param name="table"></param>
/// <param name="entities"></param>
private static void InsertBatchOfElevationDataSetTableEntity(CloudTable table, List<ElevationDataSetTableEntity> entities)
{
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (ElevationDataSetTableEntity tableEntity in entities)
batchOperation.InsertOrReplace(tableEntity);
try
{
table.ExecuteBatch(batchOperation);
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}