/// <summary>
/// This method will delete rows for the table name specified corresponding to the filter criteria. If no filter criteria is specified, all rows will be deleted.
/// </summary>
/// <param name="TableNameToDelete">Name of table from entries will be deleted.</param>
/// <param name="TimeoutSeconds">Set timeout for table client.</param>
/// <param name="filters">A list of Filter objects to be applied to table rows to delete.</param>
/// <returns>A string indicating the result of the operation.</returns>
public string DeleteAzureTableRows(string TableNameToDelete, int TimeoutSeconds = 30, List <Filter> filters = default(List <Filter>))
{
if (String.IsNullOrWhiteSpace(TableNameToDelete))
{
throw new ParameterSpecException("TableNameToDelete rows from is missing.");
}
if (!Filter.AreFiltersValid(filters))
{
throw new ParameterSpecException(String.Format("One or more of the supplied filter criteria is invalid."));
}
try
{
if (!CosmosTable.CloudStorageAccount.TryParse(new System.Net.NetworkCredential("", AzureTableConnectionSpec).Password, out CosmosTable.CloudStorageAccount StorageAccountSource))
{
throw new ConnectionException("Can not connect to CloudStorage Account for Source Table. Verify connection string.");
}
CosmosTable.CloudTableClient clientSource = CosmosTable.CloudStorageAccountExtensions.CreateCloudTableClient(StorageAccountSource, new CosmosTable.TableClientConfiguration());
CosmosTable.CloudTable TableSource = clientSource.GetTableReference(TableNameToDelete);
TableSource.ServiceClient.DefaultRequestOptions.ServerTimeout = new TimeSpan(0, 0, TimeoutSeconds);
//CosmosTable.CloudTable TableDest = TableSource;
bool BatchWritten = true;
string PartitionKey = String.Empty;
CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
int BatchSize = 100;
int BatchCount = 0;
long TotalRecordCountIn = 0;
long TotalRecordCountOut = 0;
CosmosTable.TableContinuationToken token = null;
do
{
CosmosTable.TableQuery <CosmosTable.DynamicTableEntity> tq;
if (default(List <Filter>) == filters)
{
tq = new CosmosTable.TableQuery <CosmosTable.DynamicTableEntity>();
}
else
{
tq = new CosmosTable.TableQuery <CosmosTable.DynamicTableEntity>().Where(Filter.BuildFilterSpec(filters));
}
var queryResult = TableSource.ExecuteQuerySegmented(tq, token);
foreach (CosmosTable.DynamicTableEntity dte in queryResult.Results)
{
TotalRecordCountIn++;
if (String.Empty.Equals(PartitionKey))
{
PartitionKey = dte.PartitionKey;
}
if (dte.PartitionKey == PartitionKey)
{
Batch.Delete(dte);
//Batch.InsertOrReplace(dte);
BatchCount++;
TotalRecordCountOut++;
BatchWritten = false;
}
else
{
try
{
TableSource.ExecuteBatch(Batch);
Batch = new CosmosTable.TableBatchOperation();
PartitionKey = dte.PartitionKey;
Batch.Delete(dte);
//Batch.InsertOrReplace(dte);
BatchCount = 1;
TotalRecordCountOut++;
BatchWritten = false;
}
catch (Exception ex)
{
throw new DeleteFailedException(String.Format("Table '{0}' row delete failed.", TableNameToDelete), ex);
}
}
if (BatchCount >= BatchSize)
{
try
{
TableSource.ExecuteBatch(Batch);
PartitionKey = String.Empty;
Batch = new CosmosTable.TableBatchOperation();
BatchWritten = true;
BatchCount = 0;
}
catch (Exception ex)
{
throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
}
}
}
token = queryResult.ContinuationToken;
} while (token != null);
if (!BatchWritten)
{
try
{
TableSource.ExecuteBatch(Batch);
PartitionKey = String.Empty;
}
catch (Exception ex)
{
throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
}
}
return(String.Format("Table '{0}' total rows deleted {1}.", TableNameToDelete, TotalRecordCountIn));
}
catch (ConnectionException cex)
{
throw cex;
}
catch (Exception ex)
{
throw new DeleteFailedException(String.Format("Table '{0}' row deletion failed.", TableNameToDelete), ex);
}
finally
{
}
}
/// <summary>
/// Restore file created by BackupAzureTables to the destination table name specified.
/// </summary>
/// <param name="DestinationTableName">Name of the Azure Table to restore to - may be different than name backed up originally.</param>
/// <param name="InFilePathName">Complete file name and path containing the data to be restored.</param>
/// <param name="TimeoutSeconds">Set timeout for table client.</param>
/// <returns>A string indicating the table restored and record count.</returns>
public string RestoreTableFromFile(string DestinationTableName, string InFilePathName, int TimeoutSeconds = 30)
{
if (String.IsNullOrWhiteSpace(DestinationTableName))
{
throw new ParameterSpecException("DestinationTableName is missing.");
}
if (Path.GetFullPath(InFilePathName) != InFilePathName)
{
throw new ParameterSpecException(String.Format("Invalid file name/path '{0}' specified.", InFilePathName));
}
else
{
if (!File.Exists(InFilePathName))
{
throw new ParameterSpecException(String.Format("File '{0}' does not exist.", InFilePathName));
}
}
TableSpec footer = null;
try
{
if (!CosmosTable.CloudStorageAccount.TryParse(new System.Net.NetworkCredential("", AzureTableConnectionSpec).Password, out CosmosTable.CloudStorageAccount StorageAccount))
{
throw new ConnectionException("Can not connect to CloudStorage Account. Verify connection string.");
}
CosmosTable.CloudTableClient client = CosmosTable.CloudStorageAccountExtensions.CreateCloudTableClient(StorageAccount, new CosmosTable.TableClientConfiguration());
CosmosTable.CloudTable TableDest = client.GetTableReference(DestinationTableName);
TableDest.ServiceClient.DefaultRequestOptions.ServerTimeout = new TimeSpan(0, 0, TimeoutSeconds);
TableDest.CreateIfNotExists();
DynamicTableEntityJsonSerializer serializer = new DynamicTableEntityJsonSerializer();
bool BatchWritten = true;
string PartitionKey = String.Empty;
CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
int BatchSize = 100;
int BatchCount = 0;
long TotalRecordCount = 0;
using (StreamReader InputFileStream = new StreamReader(InFilePathName))
{
string InFileLine = InputFileStream.ReadLine();
while (InFileLine != null)
{
if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Header"))
{
System.Console.WriteLine(String.Format("Header {0}", InFileLine));
}
else if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Footer"))
{
footer = JsonConvert.DeserializeObject <TableSpec>(InFileLine);
System.Console.WriteLine(String.Format("Footer {0}", InFileLine));
}
else
{
CosmosTable.DynamicTableEntity dte2 = serializer.Deserialize(InFileLine);
if (String.Empty.Equals(PartitionKey))
{
PartitionKey = dte2.PartitionKey;
}
if (dte2.PartitionKey == PartitionKey)
{
Batch.InsertOrReplace(dte2);
BatchCount++;
TotalRecordCount++;
BatchWritten = false;
}
else
{
try
{
TableDest.ExecuteBatch(Batch);
Batch = new CosmosTable.TableBatchOperation();
PartitionKey = dte2.PartitionKey;
Batch.InsertOrReplace(dte2);
BatchCount = 1;
TotalRecordCount++;
BatchWritten = false;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
if (BatchCount >= BatchSize)
{
try
{
TableDest.ExecuteBatch(Batch);
PartitionKey = String.Empty;
Batch = new CosmosTable.TableBatchOperation();
BatchWritten = true;
BatchCount = 0;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
}
InFileLine = InputFileStream.ReadLine();
} // while (InFileLine != null)
//final batch
if (!BatchWritten)
{
try
{
TableDest.ExecuteBatch(Batch);
PartitionKey = String.Empty;
}
catch (Exception ex) {
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
} // using (StreamReader
if (null == footer)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed, no footer record found.", DestinationTableName));
}
else if (TotalRecordCount == footer.RecordCount)
{
//OK, do nothing
}
else
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed, records read {1} does not match expected count {2} in footer record.", DestinationTableName, TotalRecordCount, footer.RecordCount));
}
return(String.Format("Restore to table '{0}' Successful; {1} entries.", DestinationTableName, TotalRecordCount));
}
catch (ConnectionException cex)
{
throw cex;
}
catch (RestoreFailedException rex)
{
throw rex;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
finally
{
}
}
} // RestoreTableFromBlobDirect
private string RestoreFromStream(StreamReader InputFileStream, CosmosTable.CloudTable TableDest, string DestinationTableName)
{
bool BatchWritten = true;
string PartitionKey = String.Empty;
CosmosTable.TableBatchOperation Batch = new CosmosTable.TableBatchOperation();
int BatchSize = 100;
int BatchCount = 0;
long TotalRecordCount = 0;
TableSpec footer = null;
DynamicTableEntityJsonSerializer serializer = new DynamicTableEntityJsonSerializer();
try
{
string InFileLine = InputFileStream.ReadLine();
while (InFileLine != null)
{
if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Header"))
{
System.Console.WriteLine(String.Format("Header {0}", InFileLine));
}
else if (InFileLine.Contains("ProcessingMetaData") && InFileLine.Contains("Footer"))
{
footer = JsonConvert.DeserializeObject <TableSpec>(InFileLine);
System.Console.WriteLine(String.Format("Footer {0}", InFileLine));
}
else
{
CosmosTable.DynamicTableEntity dte2 = serializer.Deserialize(InFileLine);
if (String.Empty.Equals(PartitionKey))
{
PartitionKey = dte2.PartitionKey;
}
if (dte2.PartitionKey == PartitionKey)
{
Batch.InsertOrReplace(dte2);
BatchCount++;
TotalRecordCount++;
BatchWritten = false;
}
else
{
try
{
TableDest.ExecuteBatch(Batch);
Batch = new CosmosTable.TableBatchOperation();
PartitionKey = dte2.PartitionKey;
Batch.InsertOrReplace(dte2);
BatchCount = 1;
TotalRecordCount++;
BatchWritten = false;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
if (BatchCount >= BatchSize)
{
try
{
TableDest.ExecuteBatch(Batch);
PartitionKey = String.Empty;
Batch = new CosmosTable.TableBatchOperation();
BatchWritten = true;
BatchCount = 0;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
}
InFileLine = InputFileStream.ReadLine();
} // while (InFileLine != null)
//final batch
if (!BatchWritten)
{
try
{
TableDest.ExecuteBatch(Batch);
PartitionKey = String.Empty;
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
}
if (null == footer)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed, no footer record found.", DestinationTableName));
}
else if (TotalRecordCount == footer.RecordCount)
{
//OK, do nothing
}
else
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed, records read {1} does not match expected count {2} in footer record.", DestinationTableName, TotalRecordCount, footer.RecordCount));
}
}
catch (Exception ex)
{
throw new RestoreFailedException(String.Format("Table '{0}' restore failed.", DestinationTableName), ex);
}
return(String.Format("Restore to table '{0}' Successful; {1} entries.", DestinationTableName, TotalRecordCount));
}
public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch)
{
return(ExecuteBatchAsync(batch, CancellationToken.None));
}
public virtual TableBatchResult ExecuteBatch(TableBatchOperation batch, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
{
CommonUtility.AssertNotNull("batch", batch);
return(batch.Execute(ServiceClient, this, requestOptions, operationContext));
}
public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, TableRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
CommonUtility.AssertNotNull("batch", batch);
return(batch.ExecuteAsync(ServiceClient, this, requestOptions, operationContext, cancellationToken));
}
public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, TableRequestOptions requestOptions, OperationContext operationContext)
{
return(ExecuteBatchAsync(batch, requestOptions, operationContext, CancellationToken.None));
}
public virtual Task <TableBatchResult> ExecuteBatchAsync(TableBatchOperation batch, CancellationToken cancellationToken)
{
return(ExecuteBatchAsync(batch, null, null, cancellationToken));
}
