public static void AddEntities <T>(string tablename, List <T> entitieslist) where T : ITableEntity, new()
{
//Get Caller Method name
string callerMethodName = string.Empty;
try
{
//Get Caller Method name from CallerInformation class
callerMethodName = CallerInformation.TrackCallerMethodName();
//get's azure table instance
CloudTable ArchivalTable = GetAzureTableInstance(tablename);
TableBatchOperation batchOperation = new TableBatchOperation();
//insert list of entities into batch operation
foreach (T entity in entitieslist)
{
batchOperation.InsertOrReplace(entity);
if (batchOperation.Count == 100)
{
ArchivalTable.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
}
}
if (batchOperation.Count > 0)
{
ArchivalTable.ExecuteBatch(batchOperation);
}
}
catch (Exception exception)
{
//write exception into application insights
InsightLogger.Exception(exception.Message + " - Error in DataProver while adding entities to " + tablename, exception, callerMethodName);
throw new Exception();
}
}
private bool InsertOrReplace <T>(T[] entries, CloudTable table)
where T : ITableEntity
{
try
{
TableBatchOperation batch = new TableBatchOperation();
for (int i = 0; i < entries.Length; i++)
{
// Create the Delete TableOperation
batch.InsertOrMerge(entries[i]);
if (batch.Count >= 100)
{
table.ExecuteBatch(batch);
batch = new TableBatchOperation();
}
}
if (batch.Count > 0)
{
table.ExecuteBatch(batch);
}
return(true);
}
catch (Exception ex)
{
//LogHelper.GetLogger().Error(ex.ToString(), ex);
return(false);
}
}
public static async Task UpdateData()
{
Console.WriteLine("UpdateData is running");
// Job code goes here
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["StorageConnectionString"]);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("Services");
table.CreateIfNotExists();
var serviceList = await getCentrelink();
Console.WriteLine("Got {0} services", serviceList.ToList().Count);
TableBatchOperation batchOperation = new TableBatchOperation();
foreach (var result in serviceList)
{
result.PartitionKey = result.serviceType;
result.RowKey = EncodeAddressForRowKey(result.address + result.suburb);
batchOperation.InsertOrReplace(result);
Console.WriteLine("{0} entries batched for insertion", batchOperation.Count);
if (batchOperation.Count > 98)
{
Console.WriteLine("This batch is full. Sending to cloud");
table.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
}
}
table.ExecuteBatch(batchOperation);
}
private static TimeSpan InsertEntitiesInBatch(List <DynamicTableEntity> entities, CloudTable table)
{
TableBatchOperation batchOp = new TableBatchOperation();
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (DynamicTableEntity entity in entities)
{
batchOp.Add(TableOperation.Insert(entity));
if (batchOp.Count > 99)
{
table.ExecuteBatch(batchOp);
batchOp.Clear();
}
}
if (batchOp.Count > 0)
{
table.ExecuteBatch(batchOp);
}
sw.Stop();
return(sw.Elapsed);
}
/// <summary>
/// Writes an array of logging events to the log target. By default it iterates on all
/// events and passes them to "Write" method. Inheriting classes can use this method to
/// optimize batch writes.
/// </summary>
/// <param name="logEvents">Logging events to be written out.</param>
protected override void Write(IList <AsyncLogEventInfo> logEvents)
{
//must sort into containers and then into the blobs for the container
if (_getTableNameDelegate == null)
{
_getTableNameDelegate = c => TableName.Render(c.LogEvent);
}
var tableBuckets = SortHelpers.BucketSort(logEvents, _getTableNameDelegate);
//Iterate over all the tables being written to
foreach (var tableBucket in tableBuckets)
{
var tableNameFinal = CheckAndRepairTableNamingRules(tableBucket.Key);
InitializeTable(tableNameFinal);
var batch = new TableBatchOperation();
//add each message for the destination table limit batch to 100 elements
foreach (var asyncLogEventInfo in tableBucket.Value)
{
var entity = new NLogEntity(asyncLogEventInfo.LogEvent, Layout);
batch.Insert(entity);
if (batch.Count == 100)
{
_table.ExecuteBatch(batch);
batch.Clear();
}
}
if (batch.Count > 0)
{
_table.ExecuteBatch(batch);
}
}
}
private bool ExecuteBatch(CloudTable table, TableOperation[] operations)
{
try
{
TableBatchOperation batch = new TableBatchOperation();
for (int i = 0; i < operations.Length; i++)
{
// Create the Delete TableOperation
batch.Add(operations[i]);
if (batch.Count >= 100)
{
table.ExecuteBatch(batch);
batch = new TableBatchOperation();
}
}
if (batch.Count > 0)
{
table.ExecuteBatch(batch);
}
return(true);
}
catch (Exception ex)
{
//LogHelper.GetLogger().Error(ex.ToString(), ex);
return(false);
}
}
protected void InsertOrMerge(TableEntity entity, string tableName)
{
// Create the table client.
CloudTableClient tableClient = StorageAccount.CreateCloudTableClient();
// Retrieve a reference to the table.
CloudTable table = tableClient.GetTableReference(tableName);
// Create the batch operation.
TableBatchOperation batchOperation = new TableBatchOperation();
// Add the entity to the batch
batchOperation.InsertOrMerge(entity);
// Merge
try
{
table.ExecuteBatch(batchOperation);
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == 404)
{
// Create the table if it doesn't exist.
table.CreateIfNotExists();
// do the insert again
table.ExecuteBatch(batchOperation);
}
}
}
/// <summary>
/// Extends <see cref="CloudTable"/> to enable batched deleting of all entries in it.
/// </summary>
/// <typeparam name="TEntity">The type of the entities in the <paramref name="table"/>.</typeparam>
/// <param name="table">The Cloud Table where to delete all entries.</param>
/// <param name="filter">A filter for selecting the entities.</param>
public static void DeleteAllEntitiesInBatches <TEntity>(this CloudTable table, Expression <Func <TEntity, bool> > filter) where TEntity : ITableEntity, new()
{
Action <IEnumerable <TEntity> > processor = entities =>
{
var batches = new Dictionary <string, TableBatchOperation>();
foreach (var entity in entities)
{
TableBatchOperation batch = null;
if (batches.TryGetValue(entity.PartitionKey, out batch) == false)
{
batches[entity.PartitionKey] = batch = new TableBatchOperation();
}
batch.Add(TableOperation.Delete(entity));
if (batch.Count != 100)
{
continue;
}
table.ExecuteBatch(batch);
batches[entity.PartitionKey] = new TableBatchOperation();
}
foreach (var batch in batches.Values.Where(batch => batch.Count > 0))
{
table.ExecuteBatch(batch);
}
};
table.ProcessEntities(processor, filter);
}
/// <summary>
/// Writes a stream of entities to the given Azure table.
/// </summary>
/// <typeparam name="TEntity">Type of entities to be written</typeparam>
/// <param name="source">Source stream</param>
/// <param name="table">Azure table</param>
/// <returns>Subscription corresponding to the Azure writer</returns>
public static Subscription WriteToAzureTable <TEntity>(this Stream <TEntity, Epoch> source, CloudTable table)
where TEntity : ITableEntity
{
return(source.PartitionBy(x => x.PartitionKey.GetHashCode()).Subscribe((message, workerid) =>
{
string lastPartitionKey = null;
TableBatchOperation batchOperation = new TableBatchOperation();
for (int i = 0; i < message.length; ++i)
{
if (batchOperation.Count == 100 || (lastPartitionKey != null && !message.payload[i].PartitionKey.Equals(lastPartitionKey)))
{
table.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
}
lastPartitionKey = message.payload[i].PartitionKey;
batchOperation.Insert(message.payload[i]);
}
if (batchOperation.Count > 0)
{
table.ExecuteBatch(batchOperation);
}
}, (epoch, workerid) => { }, workerid => { }));
}
void ClearTable(CloudTable table)
{
foreach (var partitionKey in this.PartitionKeys())
{
TableBatchOperation batchDelete = new TableBatchOperation();
// gets all the entities in the table for this partition key
string partitionCondition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
List <DynamicTableEntity> entities = table.ExecuteQuery(new TableQuery().Where(partitionCondition)).ToList();
entities.ForEach(e =>
{
batchDelete.Add(TableOperation.Delete(e));
// Azure has a limit on batch operations
if (batchDelete.Count == 100)
{
table.ExecuteBatch(batchDelete);
batchDelete = new TableBatchOperation();
}
});
// flush out whatever is left
if (batchDelete.Count > 0)
{
table.ExecuteBatch(batchDelete);
}
}
}
private static void DeleteAllEntitiesInBatches(CloudTable table, string filter)
{
Action <IEnumerable <DynamicTableEntity> > processor = entities =>
{
var batches = new Dictionary <string, TableBatchOperation>();
foreach (var entity in entities)
{
TableBatchOperation batch = null;
if (batches.TryGetValue(entity.PartitionKey, out batch) == false)
{
batches[entity.PartitionKey] = batch = new TableBatchOperation();
}
batch.Add(TableOperation.Delete(entity));
if (batch.Count == 100)
{
table.ExecuteBatch(batch);
batches[entity.PartitionKey] = new TableBatchOperation();
}
}
foreach (var batch in batches.Values)
{
if (batch.Count > 0)
{
table.ExecuteBatch(batch);
}
}
};
ProcessEntities(table, processor, filter);
}
private static void saveData(newsItems items, string tableName)
{
//return if no items to process
if (items.NewsItems.Count == 0)
{
return;
}
CloudTable table = getTableStorage(tableName);
// Create the table if it doesn't exist.
table.CreateIfNotExists();
// Create the batch operation.
TableBatchOperation batchOperation = new TableBatchOperation();
// Create the TableOperation object that inserts the customer entity.
foreach (newsItem item in items.NewsItems)
{
batchOperation.InsertOrReplace(item);
//update in batches of 100
if (batchOperation.Count >= 100)
{
table.ExecuteBatch(batchOperation);
batchOperation.Clear();
}
}
// Execute the insert operation for anything left over
if (batchOperation.Count > 0)
{
table.ExecuteBatch(batchOperation);
}
}
internal static void DeleteAllEntitiesInBatches(CloudTable table, string partitionKey)
{
void processor(IEnumerable <DynamicTableEntity> entities)
{
var batches = new Dictionary <string, TableBatchOperation>();
foreach (var entity in entities)
{
if (batches.TryGetValue(entity.PartitionKey, out TableBatchOperation batch) == false)
{
batches[entity.PartitionKey] = batch = new TableBatchOperation();
}
batch.Add(TableOperation.Delete(entity));
if (batch.Count == 100)
{
table.ExecuteBatch(batch);
batches[entity.PartitionKey] = new TableBatchOperation();
}
}
foreach (var batch in batches.Values)
{
if (batch.Count > 0)
{
table.ExecuteBatch(batch);
}
}
}
ProcessEntities(table, processor, partitionKey);
}
/// <summary>
/// Clear the Log.
/// </summary>
public void ClearLog()
{
CloudTable table = _cloudTableClient.GetTableReference(LogsTable);
string partitionKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "0");
TableQuery <LogEntity> query = (new TableQuery <LogEntity>()).Where(partitionKeyFilter);
LogEntity[] logEntities = table.ExecuteQuery <LogEntity>(query).ToArray();
//var query = (from e in _context.CreateQuery<LogEntity>(LogsTable).AsTableServiceQuery()
// where e.PartitionKey.Equals("0")
// select e).AsTableServiceQuery();
//IList<LogEntity> logEntities = QueryHelper<LogEntity>.All(query);
var batchOperation = new TableBatchOperation();
int count = 0;
foreach (LogEntity logEntity in logEntities)
{
batchOperation.Delete(logEntity);
if (count > 98)
{
table.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
count = 0;
}
else
{
count++;
}
}
if (batchOperation.Count > 0)
{
table.ExecuteBatch(batchOperation);
}
}
private static int Delete(string partitionKey, CloudTable itemTable, List <string> itemKeys)
{
int numOperations = 0;
var batch = new TableBatchOperation();
foreach (var itemKey in itemKeys)
{
var entity = new DynamicTableEntity(partitionKey, itemKey);
entity.ETag = "*";
entity.Properties.Add("IsActive", new EntityProperty(false));
batch.Add(TableOperation.Merge(entity));
if (batch.Count == 100)
{
itemTable.ExecuteBatch(batch);
batch.Clear();
numOperations++;
}
}
if (batch.Count > 0)
{
itemTable.ExecuteBatch(batch);
numOperations++;
}
return(numOperations);
}
private static int Insert(string partitionKey, CloudTable itemTable, IEnumerable <Item> items)
{
int numOperations = 0;
var batch = new TableBatchOperation();
foreach (var item in items)
{
batch.Add(TableOperation.Insert(item));
if (batch.Count == 100)
{
itemTable.ExecuteBatch(batch);
batch.Clear();
numOperations++;
}
}
if (batch.Count > 0)
{
itemTable.ExecuteBatch(batch);
numOperations++;
}
return(numOperations);
}
/// <summary>
/// Process azure table storage
/// </summary>
public void ProcessTableStorage()
{
try
{
// Parse the connection string and return a reference to the storage account.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("StorageConnectionString"));
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Retrieve a reference to the table.
CloudTable table = tableClient.GetTableReference("azuretablesample");
Console.ForegroundColor = ConsoleColor.Green;
// Create the table if it doesn't exist.
if (table.CreateIfNotExists())
{
Console.WriteLine("Azure table storage successfully created.\n");
}
TableBatchOperation batchOperation = new TableBatchOperation();
//Add Car items
if (CreateCarItems(out batchOperation))
{
table.ExecuteBatch(batchOperation);
Console.WriteLine("Car items successfully added.\n");
}
batchOperation = new TableBatchOperation();
//Add Coffee items
if (CreateCoffeeItems(out batchOperation))
{
table.ExecuteBatch(batchOperation);
Console.WriteLine("Coffee items successfully added.\n");
}
// Display Car Items
GetAndDisplayCarItems(table);
// Display Coffee Items
GetAndDisplayCoffeeItems(table);
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error occurred !");
Console.WriteLine(exception);
}
Console.ReadKey();
}
public IList <TableResult> DeleteBatch(IEnumerable <ITableEntity> entities)
{
TableBatchOperation batch = new TableBatchOperation();
foreach (ITableEntity tableEntity in entities)
{
batch.Add(TableOperation.Delete(tableEntity));
}
return(Table.ExecuteBatch(batch));
}
/// <summary>
/// Creates new entities in the table using batching
/// </summary>
/// <param name="entities">The entities to store in the table</param>
public void CreateEntities(IEnumerable <T> entities)
{
var batchOperation = new TableBatchOperation();
foreach (var entity in entities)
{
batchOperation.Insert(entity);
}
_cloudTable.ExecuteBatch(batchOperation);
}
public void SaveLeaves(List <Leaf> leaves)
{
var batchOp = new TableBatchOperation();
foreach (Leaf leaf in leaves)
{
batchOp.InsertOrReplace(leaf);
}
var result = table.ExecuteBatch(batchOp);
}
/// <summary>
/// Creates new entities in the table using batching
/// </summary>
/// <param name="entities">The entities to store in the table</param>
public void CreateEntities(IEnumerable <T> entities)
{
Validate.Null(entities, "entities");
var batchOperation = new TableBatchOperation();
foreach (var entity in entities)
{
batchOperation.Insert(entity);
}
cloudTable.ExecuteBatch(batchOperation);
}
static void Main(string[] args)
{
var data = Csv.Load(@"Data\Salaries.csv");
var storageAccountName = ConfigurationManager.AppSettings.Get("storageAccountName");
var storageAccountKey = ConfigurationManager.AppSettings.Get("storageAccountKey");
CloudStorageAccount storageAccount = new CloudStorageAccount(
new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(
storageAccountName, storageAccountKey), true);
// Create the table client.
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
// Get a reference to a table named "Salary"
CloudTable salaryTable = tableClient.GetTableReference("Salary");
salaryTable.CreateIfNotExists();
// Create the batch operation.
TableBatchOperation batchOperation = new TableBatchOperation();
int maxOperations = Microsoft.WindowsAzure.Storage.Table.Protocol.TableConstants.TableServiceBatchMaximumOperations;
int rowsInBatch = 0;
foreach (DataRow row in data.Rows)
{
var salary = new SalaryEntity()
{
LeagueId = row["lgID"].ToString(),
YearId = int.Parse(row["yearID"].ToString()),
PlayerId = row["playerID"].ToString(),
TeamId = row["teamID"].ToString(),
Salary = int.Parse(row["salary"].ToString())
};
batchOperation.Insert(salary);
rowsInBatch++;
if (rowsInBatch >= maxOperations)
{
salaryTable.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
rowsInBatch = 0;
}
}
if (rowsInBatch >= 1)
{
salaryTable.ExecuteBatch(batchOperation);
}
}
public void InsertBatch(IEnumerable <T> objs)
{
List <List <T> > chunks = GetChunks(objs);
foreach (var chunk in chunks)
{
var batchOperation = new TableBatchOperation();
foreach (var obj in chunk)
{
batchOperation.Insert(obj);
}
Table.ExecuteBatch(batchOperation);
}
}
/// <summary>
/// Reduces the size of the Log to the specified size (or less).
/// </summary>
/// <param name="size">The size to shrink the log to (in bytes).</param>
private void CutLog(int size)
{
size = size * 1024;
CloudTable table = _cloudTableClient.GetTableReference(LogsTable);
string partitionKeyFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "0");
TableQuery <LogEntity> query = (new TableQuery <LogEntity>()).Where(partitionKeyFilter);
LogEntity[] logEntities = table.ExecuteQuery <LogEntity>(query).ToArray();
//var query = (from e in _context.CreateQuery<LogEntity>(LogsTable).AsTableServiceQuery()
// where e.PartitionKey.Equals("0")
// select e).AsTableServiceQuery();
//LogEntity[] logEntities = QueryHelper<LogEntity>.All(query).ToArray();
int estimatedSize = logEntities.Length * EstimatedLogEntrySize;
if (size < estimatedSize)
{
int difference = estimatedSize - size;
int entriesToDelete = difference / EstimatedLogEntrySize;
// Add 10% to avoid 1-by-1 deletion when adding new entries
entriesToDelete += entriesToDelete / 10;
if (entriesToDelete > 0)
{
var batchOperation = new TableBatchOperation();
int count = 0;
for (int i = 0; i < entriesToDelete; i++)
{
batchOperation.Delete(logEntities[i]);
if (count > 98)
{
table.ExecuteBatch(batchOperation);
batchOperation = new TableBatchOperation();
count = 0;
}
else
{
count++;
}
}
if (batchOperation.Count > 0)
{
table.ExecuteBatch(batchOperation);
}
}
}
}
public void DeleteEntities(CloudTable table, string partition = null)
{
if (!table.Exists())
{
return;
}
TableQuery query = new TableQuery();
if (partition != null)
{
query.FilterString = string.Format("PartitionKey eq '{0}'", partition);
}
var entities = table.ExecuteQuery(query);
if (entities.Any())
{
var batch = new TableBatchOperation();
foreach (var entity in entities)
{
batch.Delete(entity);
}
table.ExecuteBatch(batch);
}
}
// 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);
}
static void Main(string[] args)
{
string storageconnection =
System.Configuration.ConfigurationManager.AppSettings.Get("StorageConnectionString");
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageconnection);
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("FirstTestTable");
table.CreateIfNotExists();
//CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
//CloudQueue myqueue = queueClient.GetQueueReference("queue");
//myqueue.CreateIfNotExists();
//CloudQueueMessage newmessage = new CloudQueueMessage("This is the fifth message!");
//myqueue.AddMessage(newmessage);
//CloudQueueMessage oldmessage = myqueue.GetMessage();
//Console.WriteLine(oldmessage.AsString);
TableBatchOperation tbo = new TableBatchOperation();
CarEntity newcar = new CarEntity(124, 2012, "BMW", "X1", "Black");
tbo.Insert(newcar);
newcar = new CarEntity(125, 2012, "Honda", "Civic", "Yellow");
tbo.Insert(newcar);
newcar = new CarEntity(126, 2013, "BMW", "X1", "White");
tbo.Insert(newcar);
newcar = new CarEntity(127, 2014, "BMW", "X1", "Silver");
tbo.Insert(newcar);
table.ExecuteBatch(tbo);
//TableOperation retrieve = TableOperation.Retrieve<CarEntity>("car", "123");
//TableResult result = table.Execute(retrieve);
//if (result.Result == null)
//{
// Console.WriteLine("not found");
//}
//else
//{
// Console.WriteLine("found the car " + ((CarEntity)result.Result).Make + " " + ((CarEntity)result.Result).Model);
//}
TableQuery <CarEntity> carquery = new TableQuery <CarEntity>().Take(4);
foreach (CarEntity thiscar in table.ExecuteQuery(carquery))
{
Console.WriteLine(thiscar.Year.ToString() + " " + thiscar.Make + " " + thiscar.Model + " " + thiscar.Color);
}
Console.ReadKey();
}
// POST api/values
public string Post([FromBody] List <Data> values)
{
try
{
// 構成ファイルから Azure Storage への接続文字列を取得
string setting = CloudConfigurationManager.GetSetting("StorageConnectionString");
CloudStorageAccount account = CloudStorageAccount.Parse(setting);
// Create batch.
TableBatchOperation batch = new TableBatchOperation();
foreach (var value in values)
{
// Add Insert operation to batch.
batch.Add(TableOperation.Insert(new EventEntity(value)));
}
// Create the table client.
CloudTableClient client = account.CreateCloudTableClient();
// Get the CloudTable object reference that represents the "event" table.
CloudTable table = client.GetTableReference("event");
table.CreateIfNotExists();
// Execute batch operation.
table.ExecuteBatch(batch);
return("OK");
}
catch (Exception e)
{
return(e.Message);
}
}
/// <summary>
/// Emit a batch of log events, running to completion synchronously.
/// </summary>
/// <param name="events">The events to emit.</param>
/// <remarks>Override either <see cref="PeriodicBatchingSink.EmitBatch"/> or <see cref="PeriodicBatchingSink.EmitBatchAsync"/>,
/// not both.</remarks>
protected override void EmitBatch(IEnumerable <LogEvent> events)
{
var operation = new TableBatchOperation();
var first = true;
foreach (var logEvent in events)
{
if (first)
{
//check to make sure the partition key is not the same as the previous batch
if (partitionKey != logEvent.Timestamp.Ticks)
{
batchRowId = 0; //the partitionkey has been reset
partitionKey = logEvent.Timestamp.Ticks; //store the new partition key
}
first = false;
}
var logEventEntity = new LogEventEntity(logEvent, _formatProvider, partitionKey);
logEventEntity.RowKey += "|" + batchRowId;
operation.Add(TableOperation.Insert(logEventEntity));
batchRowId++;
}
_table.ExecuteBatch(operation);
}
private static void InsertMultipleRecords(CloudTable table)
{
var batchOperation = new TableBatchOperation();
var newOrder1 = new OrderEntity("Wolfgang", "20180405")
{
OrderNumber = "111",
ShippedDate = Convert.ToDateTime("2018/04/07"),
Status = "pending"
};
var newOrder2 = new OrderEntity("Wolfgang", "20180406")
{
OrderNumber = "222",
ShippedDate = Convert.ToDateTime("2018/04/08"),
Status = "open"
};
var newOrder3 = new OrderEntity("Wolfgang", "20180407")
{
OrderNumber = "333",
ShippedDate = Convert.ToDateTime("2018/04/09"),
Status = "shipped"
};
batchOperation.Insert(newOrder1);
batchOperation.Insert(newOrder2);
batchOperation.Insert(newOrder3);
table.ExecuteBatch(batchOperation);
}
void ClearTable(CloudTable table)
{
var deviceIds = _deviceService.GetDeviceIds();
foreach (var partitionKey in deviceIds)
{
TableBatchOperation batchDelete = new TableBatchOperation();
// gets all the entities in the table for this partition key
string partitionCondition = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey);
List<DynamicTableEntity> entities = table.ExecuteQuery(new TableQuery().Where(partitionCondition)).ToList();
entities.ForEach(e =>
{
batchDelete.Add(TableOperation.Delete(e));
// Azure has a limit on batch operations
if (batchDelete.Count == 100)
{
table.ExecuteBatch(batchDelete);
batchDelete = new TableBatchOperation();
}
});
// flush out whatever is left
if (batchDelete.Count > 0)
{
table.ExecuteBatch(batchDelete);
}
}
}
