async Task ApplyConfigurationAsync(MTableConfiguration newConfig)
{
using (await LockAsyncBuggable())
{
PrimaryKey continuationKey = InternalGetContinuationPrimaryKey();
// ExecuteQueryStreamedAsync validated that mtableQuery has no select or top.
TableQuery <MTableEntity> newTableContinuationQuery =
(continuationKey == null) ? null : new TableQuery <MTableEntity>
{
// As in ExecuteQueryAtomicAsync, we have to retrieve all
// potential shadowing rows.
// XXX: This pays even a bigger penalty for not keeping
// conditions on the primary key. But if we were to simply
// keep all such conditions, there's a potential to add
// more and more continuation filter conditions due to
// layering of IChainTable2s, which would lead to some extra
// overhead and push us closer to the limit on number of
// comparisons. Either try to parse for this or change
// ExecuteQueryStreamedAsync to always take a continuation
// primary key?
FilterString =
outer.IsBugEnabled(MTableOptionalBug.QueryStreamedFilterShadowing)
? ChainTableUtils.CombineFilters(
ChainTableUtils.GenerateContinuationFilterCondition(continuationKey),
TableOperators.And,
mtableQuery.FilterString // Could be empty.
)
: ChainTableUtils.GenerateContinuationFilterCondition(continuationKey),
};
bool justStartedNewStream = false;
// Actually, if the query started in state
// USE_OLD_HIDE_METADATA, it is API-compliant to continue
// returning data from the old table until the migrator starts
// deleting it, at which point we switch to the new table. But
// some callers may benefit from fresher data, even if it is
// never guaranteed, so we go ahead and start the new stream.
// XXX: Is this the right decision?
if (newConfig.state > TableClientState.USE_OLD_HIDE_METADATA &&
currentConfig.state <= TableClientState.USE_OLD_HIDE_METADATA &&
newTableContinuationQuery != null)
{
newTableStream = await outer.newTable.ExecuteQueryStreamedAsync(newTableContinuationQuery, requestOptions, operationContext);
newTableNext = await newTableStream.ReadRowAsync();
justStartedNewStream = true;
}
if (newConfig.state >= TableClientState.USE_NEW_HIDE_METADATA &&
currentConfig.state < TableClientState.USE_NEW_HIDE_METADATA)
{
oldTableStream.Dispose();
oldTableStream = null;
oldTableNext = null; // Stop DetermineNextSide from trying to read the old stream.
if (!outer.IsBugEnabled(MTableOptionalBug.QueryStreamedBackUpNewStream) &&
newTableContinuationQuery != null && !justStartedNewStream)
{
// The new stream could have gotten ahead of the old
// stream if rows had not yet been migrated. This
// was OK as long as we still planned to read those
// rows from the old stream, but now we have to back
// up the new stream to where the old stream was.
newTableStream.Dispose();
newTableStream = await outer.newTable.ExecuteQueryStreamedAsync(newTableContinuationQuery, requestOptions, operationContext);
newTableNext = await newTableStream.ReadRowAsync();
}
}
if (!outer.IsBugEnabled(MTableOptionalBug.QueryStreamedSaveNewConfig))
{
currentConfig = newConfig;
}
}
}