Repository navigation
Use the async Always Encrypted key store APIs on async execution paths - #4585
cheenamalhotra wants to merge 137 commits into
Conversation
Async command execution now resolves Always Encrypted key material through the asynchronous key store provider APIs, so a provider that performs network I/O (for example Azure Key Vault) no longer blocks a thread pool thread for the duration of every column encryption key decryption, column master key signature verification, and enclave package generation. Utility layer (Phase 4): * SqlSecurityUtility gains DecryptSymmetricKeyAsync, GetKeyFromLocalProvidersAsync and VerifyColumnMasterKeySignatureAsync. * SqlSymmetricKeyCache gains GetKeyAsync, which never holds the cache lock across provider I/O. Call sites (Phase 5): * sp_describe_parameter_encryption result parsing is now shared by the sync and async paths. Signature verifications and key decryptions are recorded while parsing and executed afterwards, so no key store call is made while the reader is still positioned mid-stream. * The two callback-based describe-parameter-encryption continuations collapse into a single async method, preserving the existing thread pool hand-off and error/cancellation semantics. * EnclaveDelegate and SqlCommand gain async enclave package generation, used by the async execution path. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
… store calls The async key store provider APIs all accept a CancellationToken, but the Always Encrypted call sites had no way to reach the token supplied to ExecuteReaderAsync / ExecuteNonQueryAsync / ExecuteXmlReaderAsync, so key store I/O (for example an Azure Key Vault round trip) could not be cancelled. Capture the token in a per-execution field on SqlCommand, set at each async entry point and cleared by the matching cleanup continuation, and pass it to the describe-parameter-encryption key operations and to enclave package generation. A field is used rather than signature plumbing because the token would otherwise have to be threaded through several sync-only overloads of RunExecuteReader and PrepareForTransparentEncryption. Also add a manual test that registers a recording key store provider and asserts that the synchronous execution paths use the synchronous provider API, the asynchronous paths use the asynchronous provider API, and that cancelling the caller's token cancels the key store operation. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
On a query metadata cache hit the driver still loaded every column encryption key synchronously, on the caller's thread, and then generated the enclave package with the synchronous key store provider API. Both can perform key store network I/O, so an ExecuteReaderAsync that hit the metadata cache could still block the caller. Split the cache lookup into an in-memory probe (TryGetCachedQueryMetadata), which matches the cached cipher metadata onto the parameters and reports which keys still need decrypting, and a completion step that loads those keys. The synchronous lookup is now expressed in terms of the same probe, so its behaviour, including the stale key fallback and the cache hit/miss counters, is unchanged. Asynchronous execution now takes the probe and returns a task for the key loads, which means the cache hit path produces a describe-parameter-encryption task exactly like the cache miss path does. As a result it also picks up the asynchronous enclave package generation and no longer issues the command's TDS write from the caller's thread. When the cached key information turns out to be stale, that task falls back to a full describe parameter encryption round trip. The command still reports usedCache = true in that case because the caller has already returned; this is deliberately conservative, since over-reporting a cache hit can only cost one extra retry of an already failing execution, whereas under-reporting it would suppress the retry a genuine cache hit needs. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
There was a problem hiding this comment.
Pull request overview
This PR wires the async SqlColumnEncryptionKeyStoreProvider APIs into the Always Encrypted async execution paths so ExecuteReaderAsync / ExecuteNonQueryAsync / ExecuteXmlReaderAsync no longer block threads on key store network I/O (e.g., Azure Key Vault), while preserving sync behavior and error semantics.
Changes:
- Adds async counterparts in the Always Encrypted utility/enclave layers (e.g.,
SqlSecurityUtility.DecryptSymmetricKeyAsync,SqlSymmetricKeyCache.GetKeyAsync,EnclaveDelegate.GenerateEnclavePackageAsync). - Refactors describe-parameter-encryption processing to share parsing between sync/async and to defer key-store operations until after result-set parsing.
- Flows the caller’s
CancellationTokeninto AE key-store operations via per-execution state onSqlCommand, and updates query metadata cache to split probe vs. async completion.
Reviewed changes
Copilot reviewed 14 out of 14 changed files in this pull request and generated 2 comments.
Show a summary per file
| File | Description |
|---|---|
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlSecurityUtility.cs | Adds async key decryption + CMK signature verification paths with cancellation and consistent wrapping. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlSymmetricKeyCache.cs | Adds GetKeyAsync with lock-release around provider I/O to avoid blocking sync callers. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlQueryMetadataCache.cs | Splits cache lookup into in-memory probe + awaitable completion that loads CEKs asynchronously. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.cs | Introduces per-execution _asyncExecutionCancellationToken for async AE flows. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.Encryption.cs | Refactors describe-parameter-encryption processing to defer key-store ops and add async completion. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.Reader.cs | Adds async enclave package generation and replaces continuation chains with async/await + Task.Run dispatch. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.NonQuery.cs | Captures/clears per-execution cancellation token for async non-query execution. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.Xml.cs | Captures/clears per-execution cancellation token for async XML reader execution. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.cs | Adds async key resolution for enclave package generation and shares key validation/projection. |
| src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/EnclaveDelegate.Crypto.cs | Adds GenerateEnclavePackageAsync and shared helper for building the enclave package. |
| src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlSecurityUtilityAsyncShould.cs | Adds unit tests covering async decryption/signature verification/cancellation/cache behavior. |
| src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/EnclaveDelegateAsyncShould.cs | Adds unit tests asserting enclave async path uses async provider APIs and honors cancellation. |
| src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlQueryMetadataCacheAsyncShould.cs | Adds unit tests for async metadata cache completion and stale-key degradation. |
| src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/AsyncKeyStoreProviderTests.cs | Adds manual integration test verifying sync vs async provider API usage and token flow. |
💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.
GetParameterEncryptionDataReader returned void with an out Task and did nothing but dispatch asynchronous work, so its name gave no hint that the caller was receiving a pending operation. The name was inherited from main, where it was actively misleading: the overload without the Async suffix was the one that continued from a pending network write, while the overload with the suffix was the one used when that write had already completed. Rename the dispatcher to GetParameterEncryptionDataReaderAsync and have it return the task directly instead of through an out parameter, and rename the async body to ConsumeDescribeParameterEncryptionResultsAsync, which describes what it actually does. Both names now carry the Async suffix and both return a task. Also make the Task.Run rationale precise. It is not merely a convenience: the body issues blocking TDS reads before it reaches a suspension point, and PrepareForTransparentEncryption runs synchronously on the caller's thread under the async entry points, so awaiting inline would put those reads on the caller's thread whenever the network write is null or already complete. Neither continuation this replaced could run inline, since one used Task.Run and the other used ContinueWith without ExecuteSynchronously. No behaviour change. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
There was a problem hiding this comment.
Pull request overview
Copilot reviewed 14 out of 14 changed files in this pull request and generated no new comments.
Suppressed comments (1)
Previously missed (1) — in code that hasn't changed since the last review.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.cs:160
- _asyncExecutionCancellationToken is documented as representing the token “currently in flight”, but it looks like it’s only cleared in the async cleanup continuations. If an async entry point throws during setup (e.g., Task.Factory.FromAsync throws before the continuation runs), the token can remain set on the SqlCommand instance, unnecessarily retaining the caller’s CancellationTokenSource and violating the stated invariant. Consider clearing this field in the synchronous exception paths of InternalExecuteReaderAsync / InternalExecuteNonQueryAsync / InternalExecuteXmlReaderAsync as well (before returning a faulted Task).
/// <summary>
/// Cancellation token supplied by the caller of the asynchronous execution that is currently in
/// flight, or <see cref="CancellationToken.None"/> when the command is executing synchronously.
/// </summary>
/// <remarks>
Report CreateColumnEncryptionKeyInfo as the throwing member in the internal null-argument diagnostics. The throws moved into that shared helper and are now reachable from both the sync and async decrypt paths, so naming GetDecryptedKeysToBeSentToEnclave was misleading. This also matches the convention used by EncryptBytePackage and ComputeQueryStringHash in the same type. Use TdsEnums.AEAD_AES_256_CBC_HMAC_SHA256 and SqlClientEncryptionType.Deterministic in the query metadata cache tests instead of bare literals with explanatory comments. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
There was a problem hiding this comment.
Pull request overview
Copilot reviewed 14 out of 14 changed files in this pull request and generated no new comments.
Suppressed comments (4)
Previously missed (1) — in code that hasn't changed since the last review.
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlQueryMetadataCacheAsyncShould.cs:90
SqlCommand(and its underlyingSqlConnection) should be disposed in this test to avoid leaking resources across the unit test process; use ausingdeclaration for the cached command instance.
This issue also appears in the following locations of the same file:
- line 113
- line 137
- line 150
TestKeyStoreProvider provider = new TestKeyStoreProvider { PlaintextKey = NewPlaintextKey(seed: 41) };
SqlCommand command = NewCachedCommand(provider);
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlQueryMetadataCacheAsyncShould.cs:115
- This test creates a
SqlCommandwith an ownedSqlConnectionbut never disposes it; prefer ausingdeclaration so the connection/command are cleaned up even if the test fails.
};
SqlCommand command = NewCachedCommand(provider);
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlQueryMetadataCacheAsyncShould.cs:152
- Use a
usingdeclaration for theSqlCommandcreated byNewCachedCommandso the command/connection are disposed deterministically.
TestKeyStoreProvider provider = new TestKeyStoreProvider { PlaintextKey = NewPlaintextKey(seed: 43) };
SqlCommand command = NewCachedCommand(provider);
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlClient/AlwaysEncrypted/SqlQueryMetadataCacheAsyncShould.cs:139
- Dispose the
SqlCommandcreated for this test (it owns aSqlConnection) to avoid resource leakage across the unit test run.
TestKeyStoreProvider provider = new TestKeyStoreProvider { PlaintextKey = NewPlaintextKey(seed: 47) };
SqlCommand command = NewCachedCommand(provider);
A pass over the async Always Encrypted work looking for correctness, performance, and consistency problems. The behavioural changes: Capture the cancellation token on the originating thread. The token lives in a field so it does not have to be threaded through layers of callback-driven code that have no use for it, but the Always Encrypted work is handed to the thread pool and can outlive the cleanup continuation that resets that field. Reading it late could silently observe CancellationToken.None. It is now read once at the two synchronous capture points and passed on as an explicit parameter. Make the symmetric key cache insert non-cancellable. Cancelling between a successful decrypt and the cache insert threw away a key that had already cost a key store round trip, so the next caller paid for it again. Drop a dead serverName parameter from both GetDecryptedKeysToBeSentToEnclave overloads, and give the result list a capacity hint. The rest is allocation and clarity work: lazily allocate the pending key operation lists and hand them out as IReadOnlyList, walk them by index so the interface enumerator is not boxed, and make IsEnclaveEnabled an explicit field on ColumnMasterKeySignatureVerification rather than a hard-coded true that only happens to be correct because of where the call sits. Also documents three decisions that look like missed optimisations but are not. The Task.Run in GetParameterEncryptionDataReaderAsync cannot be awaited inline because the task it waits on is completed by the SNI network callback, so an inline continuation would run blocking TDS reads on a callback thread. Column encryption key decryption stays sequential because distinct cipher metadata entries often share a key, and GetKeyAsync does not hold its gate across provider I/O, so parallel misses for the same key would each issue their own key store call. Sequential decryption lets the first result warm the cache. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
CompleteCachedQueryMetadataAsync treated every exception from the column encryption key load as evidence that the cached metadata was stale, and invalidated the entry. Cancellation is not evidence of anything of the sort, so cancelling an execution threw away a perfectly good cache entry and made the next caller pay for another describe parameter encryption round trip. Cancellation now propagates without touching the cache. This failure mode cannot arise on the synchronous path, so only the asynchronous overload handles it and the two stay otherwise identical. The existing cancellation test only asserted that the operation threw, which is why this went unnoticed. It now also asserts that the entry survives and that a subsequent uncancelled load still succeeds, and it fails without the fix. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
There was a problem hiding this comment.
Pull request overview
Copilot reviewed 14 out of 14 changed files in this pull request and generated no new comments.
Suppressed comments (2)
Previously missed (2) — in code that hasn't changed since the last review.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlSymmetricKeyCache.cs:155
- The comment says the provider exception will be “simply bubbled up”, but this method wraps non-cancellation failures in SQL.KeyDecryptionFailed. Please update the comment so it matches the actual error behavior (only OperationCanceledException is propagated unwrapped).
// Decrypt the CEK
// We will simply bubble up the exception from the DecryptColumnEncryptionKeyAsync function.
byte[] plaintextKey;
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlSecurityUtility.cs:412
- The comment says the provider exception will be “simply bubbled up”, but this helper wraps non-cancellation failures in SQL.KeyDecryptionFailed. Please update the comment so it matches the actual behavior (only OperationCanceledException is propagated unwrapped).
// Decrypt the CEK
// We will simply bubble up the exception from the DecryptColumnEncryptionKeyAsync function.
byte[] plaintextKey;
The required sqlclient-pr pipeline is failing only on tests unrelated to this change, in a pipeline with a ~48% baseline failure rate across other PRs. Observed failures, none of which touch any file in this PR: MARSTest.MarsScenarioClientJoin (also failed on PR #4567) SqlCommandCancelTest.TimeOutDuringRead_Tcp (timing sensitive) TransactionEnlistmentTest.TestManualEnlistment_Enlist (also failed on PR #4585) The /azp run comment trigger is not enabled on this repo, so refreshing the head SHA is the only available way to re-run the required checks. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: cfc64bc6-a9e6-490d-88b1-4b78d25aa103
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> Copilot-Session: 82aca8ca-2078-4a47-860c-6f6ee78cbb02
One sync/async entry dispatches to a single async method, which handles cached-key completion and enclave attestation, then calls the shared core. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
…nc-enclave-key-loading Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
There was a problem hiding this comment.
🔵 Needs a closer look
Human assessment is needed because a critical hidden finding indicates XML async callers may receive the failed first-attempt task instead of the retry result across multiple execution paths.
No open issues 🎉
Review effort: Lite
PrepareForTransparentEncryption is now a thin entry that selects the mode and adapts the result. PrepareParameterEncryption owns the cache probe, cached completion, worker hop, guard ownership and the describe fallback. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Replace the deferred-failure and dispatched flags with one holdsInProgress result. Cache hits and miss paths that complete synchronously return directly; only work that awaits runs in ContinueParameterEncryptionAsync. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
TryGetCachedQueryMetadata probes the cache. PrepareForTransparentEncryption takes the probed metadata and returns a ValueTask. RunExecuteReader acquires the in-progress flag for async preparation and hands its release to execution, which releases it on every path. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Adopt the execution-owned enclave in-progress flag (releaseInProgress), the new PrepareForTransparentEncryption signature, and retarget the reflection-based enclave tests to the current entry points. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
…om/dotnet/SqlClient into dev/cheena/ae-async-enclave-key-loading # Conflicts: # src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.Reader.cs
There was a problem hiding this comment.
🔵 Needs a closer look
Human assessment is needed because the change has unresolved correctness risks in deferred encryption-result handling and cache consistency under concurrent execution.
No open issues 🎉
1 resolved since last review
Review effort: Lite
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Reading SqlCommand.Transaction during a pending cached key load cleared the binding, so execution skipped the TransactionZombied check. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
The pending-package-key test helper now owns the in-progress flag like RunExecuteReader, so overlapping executions are rejected instead of blocking on the pending key. RunExecuteReader sets the flag before the cache probe so overlaps started there are rejected too. Test awaits on overlapping executions are bounded. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
There was a problem hiding this comment.
🔵 Needs a closer look
Human assessment is needed because the change contains critical concurrency and cleanup risks that could leave connections occupied, leak sessions, or corrupt or discard refreshed metadata.
No open issues 🎉
Review effort: Lite

Description
SqlColumnEncryptionKeyStoreProvidergained async APIs in #4540, but the driver did not call them. This PR wires those APIs intoSqlCommandparameter-encryption and enclave-package key loading, so asynchronous command execution can await key-store I/O.Async utility layer
Adds async counterparts to
SqlSecurityUtility.DecryptSymmetricKey,GetKeyFromLocalProviders,VerifyColumnMasterKeySignature,AlwaysEncrypted.SymmetricKeyCache.GetKey, and enclave-package key loading/generation.Async cold-cache misses use a per-key gate and cache recheck to avoid duplicate unwraps. Provider invocation shares the existing synchronous-provider gate, preserving serialization for legacy providers whose base async method calls synchronous code. The returned task is awaited outside that gate, allowing outstanding async I/O for different keys to overlap. Cache publication uses a separate short in-memory lock; sync/async races retain first-published key identity.
Validation, provider error wrapping, cache behavior, and multi-key fallback are preserved. No public API changes. Synchronous callers retain synchronous provider dispatch.
Call site integration
Sync and async describe-parameter-encryption paths share one parser.
ReadDescribeEncryptionParameterResultsCorerecords signature verifications and key decryptions inPendingColumnEncryptionKeyOperations; sync and async wrappers then execute that work after parsing.Enclave-package generation and post-describe execution gain async counterparts using shared validation and package-building helpers. Deferred retryable package faults use the existing cache/session invalidation and bounded retry handler.
Cancellation
Reader, NonQuery, and XML async entry points capture the caller token, pass it to key-store operations, and clear it during execution cleanup. Cancellation after describe-phase state release avoids accessing a released state object. Cancellation takes precedence over candidate/CMK validation and provider errors. CMK verification checks cancellation before accepting true/false results or publishing signature-cache entries. Successful key decryption still publishes its result when cancellation arrives afterward.
Query metadata cache
Cache lookup is split into an in-memory probe and an awaitable key-loading completion. Async completion is dispatched to a worker so synchronously completed provider tasks cannot run the stale-cache describe fallback on the caller thread. Sync lookup uses the same probe without changing its dispatch behavior.
Notes for reviewers
usedCacheremains conservatively over-reported on stale-key describe fallback, preserving the existing single retry for conversion errors.Task.Runis deliberate at boundaries that can issue blocking TDS work, including cached-key completion when providers complete synchronously.OperationCanceledException.Behaviour notes worth a careful look
Exception ordering on malformed describe results. Parsing finishes before key-store work. If results are malformed and contain an invalid key, the parsing error can now surface first.
Network callback threads. Describe-result and post-describe work retain their worker dispatches rather than performing blocking TDS work on SNI callbacks.
Sequential key loading. Distinct metadata entries can share a key; sequential loading lets the first result warm the cache without duplicate provider I/O.
Scope
This PR covers
SqlCommandparameter-encryption and enclave-package key loading, including Reader, NonQuery, and XML async execution. Async enclave attestation is separate (#4886/#4887); those branches were not imported. Session lookup may still perform synchronous attestation I/O, as the enclave-package remarks state.SqlBulkCopy.WriteToServerAsyncstill reaches synchronous key decryption throughCopyBatchesAsync/TdsParser.LoadColumnEncryptionKeys. Those implementations are unchanged and remain deferred work under #3672.Issues
Part of #3672, following #4540.
Testing
Regression coverage includes sync/async provider dispatch, multi-key fallback, cancellation and command reuse, CMK signature-cache cancellation, metadata-cache completion, deferred package retry outcomes, same-key cold-cache deduplication, independent keys, and sync/async publication races.
Latest fix
284463de5restores legacy synchronous-provider serialization without holding the gate across outstanding async I/O. Both new regression cases failed before the fix and pass afterward: a distinct-key waiter cancels without entering the blocked synchronous provider, then succeeds on retry. Earlier3ec157d48moved intentionally blocking test-provider work to a dedicated thread andfinally-owned release, preserving completion and identity assertions.Local validation on
284463de5:Passed: 87 tests in Debug and 87 in Release.
Both passed with zero warnings/errors.
Manual run on earlier head
3b10197ce:All eight cases were discovered and skipped because local AE configuration is unavailable. Server-side enclave retry validation remains outstanding. A prior full local unit run aborted in simulated-routing teardown; the isolated case also hangs on unchanged main
616aeff04. No routing tests were changed or disabled.Current-head CI build 188785, through merge
995d74c410171d423366b766df90cf67a515a2af: all three unit and all three AE tasks passed. Linux Azure manual tests encountered schema-discovery deadlocks; Linux localhost manual tests encountered unsupported distributed-transaction promotion in a pool-reuse test. One failed-job-only Linux retry is in progress; passing jobs were not rerun.Build 188783 exhausted its two automatic Windows Azure net462 manual-job retries. All failures were schema-discovery deadlocks in
AddTVPsToDataTypesTableAsync, including vector metadata tests usingGetSchema. These unchanged paths do not invoke key providers. The user explicitly requested leaving these failures outside this PR; no unrelated fixes, weaker assertions, or further retries were applied.The milestone remains 8.1.0-preview1 by explicit user decision. Main's active line and
SqlClientNextVersionremain8.0.0-preview1, so the two milestone checks remain intentionally blocked. No milestone, release version, or check configuration was changed to bypass the gate.Guidelines
Please review the contribution guidelines before submitting a pull request: