[apoorvdeshmukh]

Description

Adds vector(N, float16) support while preserving the shipped float32 API:

• Modern .NET supports SqlVector<Half>; .NET Framework uses string/SqlString results or explicit lossless widening through GetSqlVector<float>.
• 8.0 behavior change: Vector Type Support defaults to V2. Select V1 to preserve float16 JSON-string results, or Off for all-text vector results.
• Native vector bulk copies preserve the source base type; SQL Server performs cross-base conversion. JSON-string input to float16 uses explicit UTF-8 transport. No client-side narrowing encoder is added.
• Vector-specific bulk metadata is limited to native vector destinations. Missing optional reader metadata preserves legacy inputs; ordinary text copies gain no extra metadata calls or row scans. Typed vectors are not automatically serialized for text destinations; supply JSON strings instead. Existing string-valued paths remain unchanged.
• Includes reader/schema/output-parameter handling, Framework CommandBuilder support, regression coverage, samples, and retained capability-probe diagnostics. Vector TVPs and new outgoing-version guards remain outside scope.

Includes main through 827c13651. Bulk-copy compatibility update: 53d8e4603; Debug/Release JSON rejection correction: 21f8750da.

• Tests added or updated
• Public API changes documented
• Verified against reported scenarios on local SQL Server and Azure SQL
• Ensure no breaking changes introduced to the shipped float32 API

Issues

API discussion: #3382

Testing

Latest CI correction: 270 targeted checks passed, zero failures/skips. JSON vector input is now rejected at SqlBulkCopy.ConvertValue, before the shared XML/JSON assertion or writer. The regression reproduced as DebugAssertException in Debug and missing early rejection in Release; assertions and valid JSON/XML handling were not weakened.

Configuration / suite	net462	net10.0
Debug unit tests	22	29
Release unit tests	22	29
Debug integration tests, local SQL Server	38	46
Release integration tests, local SQL Server	38	46

Earlier broader validation on 53d8e4603 passed 1,777 repository tests and 1,616 local/Azure matrix checks, including expected rejections. That execution coverage was Release-only and did not exercise the Debug assertion path found by CI. Reference/sample/package builds, Unix-target compilation, and strict source XML validation passed.

CI audit (build 188293): All added test methods have passing CI results except Utf8TextSourceAcrossDatabases (sync/async), skipped in every lane. Both variants passed locally on net462/net10; CI coverage requires a float16-enabled SQL Server instance with cross-database access, which the Azure SQL Database CI lane does not provide.

Known limitation: strict packaged XML still reports two pre-existing SqlTriggerContext references from TriggerAction; no new gating XML findings. This is focused validation, not a full-suite or performance-benchmark claim.

Latest correction: commands and results

$root is the local validation-artifact directory. Integration tests used TEST_MDS_CONFIG and MDS_TCPConnectionString for an isolated local database. Each configuration was built and its filter verified with --list-tests before these --no-build runs.

# Passed in each configuration: 22 net462 + 29 net10.0 unit tests.
foreach ($configuration in @('Debug','Release')) {
    dotnet test src\Microsoft.Data.SqlClient\tests\UnitTests\Microsoft.Data.SqlClient.UnitTests.csproj --no-build --no-restore -c $configuration -p:TestTfmsInParallel=false --filter 'FullyQualifiedName~SqlBulkCopyTests|FullyQualifiedName~SqlParameterTests|FullyQualifiedName~VectorMetadataTests' --blame-hang-timeout 10m --logger "trx;LogFilePrefix=nov02-json-$configuration-unit" --results-directory "$root\nov02-json-debug-results" --verbosity minimal
}

# Passed in each configuration: 38 net462 + 46 net10.0 integration tests.
foreach ($configuration in @('Debug','Release')) {
    dotnet test src\Microsoft.Data.SqlClient\tests\ManualTests\Microsoft.Data.SqlClient.ManualTests.csproj --no-build --no-restore -c $configuration -p:TestTfmsInParallel=false --filter 'FullyQualifiedName~ReaderVectorsToJsonAreRejected|FullyQualifiedName~JsonReaderDoesNotRequireSchema|FullyQualifiedName~BulkCopyFloat16ReaderUsesExistingTextConversions|FullyQualifiedName~JsonBulkCopyTest' --blame-hang-timeout 10m --logger "trx;LogFilePrefix=nov02-json-$configuration-manual" --results-directory "$root\nov02-json-debug-results" --verbosity minimal
}

The new ConvertValue_NativeVectorForJson_ThrowsConversionError cases failed before the correction in both configurations. Existing string, SqlString, and SQL-null control cases passed before and after it. The separate SqlParameter.CoerceValue text-destination tests also remain passing; the CI failure was in bulk copy's separate JSON path, not raw bytes being returned for text parameters.

Guidelines

Please review the contribution guidelines before submitting a pull request:

• Contributing
• Code of Conduct
• Best Practices
• Coding Style
• Review Process

[Copilot]

Pull request overview

Adds end-to-end support for SQL Server vector(N, float16) by negotiating VECTORSUPPORT feature extension version 2, introducing an IEEE-754 binary16 codec, and wiring float16 handling through SqlVector<T> read/write paths (including bulk copy), with accompanying docs and tests.

Changes:

• Negotiate vector feature extension v2 and track negotiated vector capability version (float32/float16) on the connection.
• Add float16 vector support across SqlVector<T>, SqlDataReader, SqlBuffer, SqlParameter, SqlCommand, and SqlBulkCopy, including payload conversion for bulk copy.
• Add unit/manual tests plus docs/snippets/sample updates; expose vector base type + dimensions via DbColumn indexer and register vector in the DataTypes schema collection.

Reviewed changes

Copilot reviewed 23 out of 23 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
src/Microsoft.Data.SqlClient/tests/UnitTests/SimulatedServerTests/ConnectionTests.cs	Updates simulated negotiation tests for vector feature extension v2.
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlTypes/SqlVectorTest.cs	Adds float16 construction/rendering tests and payload conversion tests.
src/Microsoft.Data.SqlClient/tests/UnitTests/Microsoft/Data/SqlTypes/Float16ConverterTest.cs	New unit tests validating binary16 codec (incl. exhaustive bit-pattern validation on .NET).
src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/VectorFloat16BehaviourTests.cs	Manual tests for float16-specific behaviors (read/write/cross-base-type/bulk copy).
src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/VectorColumnMetadataTests.cs	Manual tests for vector column metadata + schema collection registration.
src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat16Tests.cs	Manual typed tests for SqlVector<Half> on .NET.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlTypes/SqlVector.cs	Implements float16 support in SqlVector<T>, adds JSON ToString(), payload widening/conversion helpers.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/TdsEnums.cs	Adds vector version constants and sets max supported vector version to float16 (v2).
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlParameter.cs	Handles float16 vector return/coercion paths (Half on .NET, widening on netfx).
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlMetaDataFactory.DataTypes.cs	Registers vector in GetSchema("DataTypes").
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlEnums.cs	Adds float16 vector element type and element-size mapping; meta type inference includes SqlVector<Half> on .NET.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlDbColumn.cs	Exposes VectorBaseType/VectorDimensions via DbColumn indexer.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlDataReader.cs	Adds float16 field-type mapping and broadens GetSqlVector<T> to allow Half on .NET.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.cs	Emits (N, float16) parameter declaration when needed (keeps float32 declaration unchanged).
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlBulkCopy.cs	Emits float16 vector type in INSERT BULK declaration and converts payload base type to match destination.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlBuffer.cs	Centralizes float16 vector rendering/value-shaping across frameworks.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/Connection/SqlConnectionInternal.cs	Records negotiated vector feature version on FEATUREEXTACK.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/Connection/ConnectionCapabilities.cs	Replaces bool flag with VectorVersion and derived float32/float16 capability properties.
src/Microsoft.Data.SqlClient/src/Microsoft/Data/Common/Float16Converter.cs	New internal binary16<->binary32 conversion implementation.
src/Microsoft.Data.SqlClient/ref/Microsoft.Data.SqlTypes.cs	Updates reference surface to include SqlVector<T>.ToString() override.
doc/snippets/Microsoft.Data.SqlTypes/SqlVector.xml	Documents float16 support, size constraints, and ToString() JSON rendering.
doc/samples/SqlVectorFloat16Example.cs	New sample demonstrating float16 vectors (insert/read/metadata).
.github/instructions/features.instructions.md	Updates repo feature reference docs for float16 vector base type and negotiation versions.

Suppressed comments (1)

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlTypes/SqlVector.cs:420

• ConvertPayloadElementType doesn’t validate the vector header magic/version bytes before using the length and element type fields. This can cause non-vector payloads to be converted (or to fail later with less appropriate exceptions). Validate VecHeaderMagicNo/VecVersionNo up front, consistent with GetCountsOrThrow.

        if (tdsBytes.Length < TdsEnums.VECTOR_HEADER_SIZE)
        {
            throw ADP.InvalidVectorHeader();
        }

[Copilot]

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated no new comments.

Suppressed comments (4)

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlBulkCopy.cs:1755

• SqlTypes.SqlVector<float> doesn’t resolve to any namespace/type in this file (there’s no using SqlTypes = ... and no SqlTypes namespace). This should be fully qualified to Microsoft.Data.SqlTypes.SqlVector<float> (or add an alias) to avoid a compile error.

            // The payload is converted directly rather than through a strongly typed vector,
            // so that .NET Framework, which has no System.Half, can also write to float16
            // destinations.
            return SqlTypes.SqlVector<float>.ConvertPayloadElementType(payload, destinationElementType);

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlTypes/SqlVector.cs:154

• FromTdsPayload reads header fields (element type/length) without validating the vector magic/version bytes. This makes the widening path accept malformed payloads that GetCountsOrThrow would reject.

        if (tdsBytes.Length < TdsEnums.VECTOR_HEADER_SIZE)
        {
            throw ADP.InvalidVectorHeader();
        }

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlTypes/SqlVector.cs:420

• ConvertPayloadElementType should validate the vector header magic/version before interpreting element type and length; otherwise malformed byte[] values can be converted and sent on the wire rather than failing fast with InvalidVectorHeader.

        if (tdsBytes.Length < TdsEnums.VECTOR_HEADER_SIZE)
        {
            throw ADP.InvalidVectorHeader();
        }

doc/samples/SqlVectorFloat16Example.cs:146

• These interpolated strings won’t compile because the expression uses double quotes (e.g., column["VectorBaseType"]) inside a double-quoted string literal. Escape the quotes (or assign to a local variable) before interpolating.

        Console.WriteLine($"\nColumn base type:  {column["VectorBaseType"]}");
        Console.WriteLine($"Column dimensions: {column["VectorDimensions"]}");

[Copilot]

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated no new comments.

Suppressed comments (2)

doc/samples/SqlVectorFloat16Example.cs:146

• These interpolated strings won’t compile because the expression contains a string literal with double quotes (e.g., column["VectorBaseType"]) which terminates the outer interpolated string. Assign the indexer results to variables (or constants) first, then interpolate those variables.

        Console.WriteLine($"\nColumn base type:  {column["VectorBaseType"]}");
        Console.WriteLine($"Column dimensions: {column["VectorDimensions"]}");

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlParameter.cs:2408

• This SqlVector special-case is redundant/unreachable because SqlVector implements ISqlVector (so it will already be handled by the earlier value is ISqlVector branch). Keeping the extra branch increases maintenance burden and risks diverging behavior.

                    else if (currentType == typeof(SqlVector<Half>))
                    {
                        value = ((ISqlVector)value).VectorPayload;
                    }
                    #endif

[saurabh500]

Summary

This adds vector(N, float16) by advertising VECTORSUPPORT v2, introducing a hand-written binary16 codec, teaching SqlVector<T> about System.Half, and switching vector→vector bulk copy to a raw-payload transfer. The engineering is careful, and I want to call out specifically that the endianness and element-size arithmetic is correct throughout — I went looking for a missed (ColumnSize - 8) / 4 and there isn't one. The commit split is clean and the rationale in the description is unusually good.

I have one blocking correctness issue, plus a set of suggestions. Inline comments carry the detail and suggested diffs; this is the map.

Blocking

• SqlBuffer.GetSqlVector<T>() succeeds or throws depending on the row's nullness. The IsNull branch builds a vector for any T without consulting the column's base type, while the non-null branch validates. GetSqlVector<Half>() over a float32 column therefore returns Null for NULL rows and throws NotSupportedException for non-NULL rows in the same result set. Data-dependent rather than schema-dependent, so it is hard to find in testing and impossible to guard against in caller code.

Suggestions

• The codec is not bit-exact against System.Half for NaN, contrary to the description, and the tests are written to step around exactly that case (continue / IsNaN-only). float.NaN carries the sign bit, so widening flips the sign of every NaN relative to System.Half; narrowing canonicalises payloads that (Half)float preserves. Either match System.Half or pin the canonical form with explicit assertions and drop the "bit-exact" claim.
• Bulk copy's vector case uses metadata.scale rather than the scale local that the surrounding code establishes for encrypted columns.
• The widening path skips the magic-number and version validation that the matching path gets via GetCountsOrThrow.
• Capabilities.Float16VectorType is never read anywhere in src/, so a SqlVector<Half> on a v1-negotiated connection fails server-side rather than client-side. (Float32VectorType was already dead in main; this adds a second.)
• The negotiation theory's 0x3 case doesn't test what its comment claims — the simulated server caps the ack itself, so the client's own ceiling check at SqlConnectionInternal.cs:1660 stays untested.
• Docs say narrowing "fails for values outside its range"; the code saturates to ±Infinity and leaves it to the server.
• MetaData is dereferenced without a null check in CreateSourceColumnMetadata.

Things I checked and found correct

Worth recording, since they're the parts most likely to be wrong in a change like this:

• Subnormal widening, signed zero, overflow to infinity, the flush-to-zero boundary (2⁻²⁵ ties to even → 0, 2⁻²⁶ flushes), binary32 subnormal inputs, and the rounding carry into the exponent are all correct. Compiling Manual* on every TFM so the netfx path is under test on .NET too is a good arrangement.
• Bulk copy null handling is correct as-is — GetValueFromSourceRow returns DBNull.Value with isNull = true and ConvertValue returns before ConvertVectorToBaseType. Note a5de733c3 is test-only; it documents behaviour that already worked rather than fixing anything.
• The raw-payload path can't be taken by DataTable, DataRow[], or non-SqlClient DbDataReader sources (they keep ValueMethod.GetValue), and reordering column mappings are safe because sourceOrdinal is the mapped ordinal.
• No unacknowledged breaking changes beyond the three listed: GetDataTypeName is unchanged, GetFieldType/GetProviderSpecificFieldType both route through the single new GetVectorFieldType so they stay consistent, SqlMetaDataFactory.DataTypes only adds a row (gated on MinimumVersionKey), the float32 declaration is deliberately unchanged, and SqlDbColumn's new indexer falls through to base[property].
• No shared mutable state: Float16Converter is stateless and SqlVector<T> is a readonly struct with no static caches.

On testing

Taking as given that CI has no float16-capable server and no Azure SQL DB connectivity, so the manual suite is the only gate that will ever run — I looked at whether it is complete enough for a lab run rather than whether CI covers it. It is substantial: 11 behaviour tests plus the inherited NativeVectorTestsBase matrix, and the sample data is well chosen (Half.MaxValue, Half.Epsilon, -0.0f, exactly-representable eighths). Gaps I'd close:

1. .NET Framework gets none of the NativeVectorTestsBase matrix — NativeVectorFloat16Tests.cs is entirely #if NET. That is where the hand-rolled Manual* codec is the production path.
2. No async coverage for the new representation on any framework, and none at all for float16 on netfx.
3. DataTestUtility.CheckVectorFloat16Supported fails open through the code under test. It reads the probe vector with GetString + JsonSerializer.Deserialize and catches JsonException → false. A driver regression that produces malformed JSON silently skips the whole float16 suite green. Since the manual run is the only gate, that is the wrong failure mode. (Outside this diff, so no inline comment — but worth fixing alongside. It also leaves PREVIEW_FEATURES = ON on the shared test database as a side effect.)
4. Two range tests assert only that some SqlException was thrown; they'd pass on an unrelated failure, and they can't distinguish "client rejects" from "client saturates and server rejects" — which is exactly the ambiguity in the doc wording above.
5. Nothing covers the blocking issue: reading a float32 column as SqlVector<Half>, for a NULL and a non-NULL row.
6. Bulk copy with a dimension-count mismatch between source and destination is uncovered. Mitigating: float32→float32 now routes through the new raw-payload path too and is covered by the existing NativeVectorFloat32Tests, which runs against any vector-capable server — so regression risk to shipped functionality is covered.

Minor

• SqlVector<T>.ToString() changing for existing SqlVector<float> callers is justified and correctly surfaced in the ref assembly and docs, but it is unrelated to float16 — it wants its own release-note entry as a behavioural break, not just an API-list line. Related: GetString() uses JsonSerializer.Serialize, which throws on NaN/Infinity by default, and on .NET Framework that is now the default GetValue() path.
• ConvertPayloadElementType is internal static on SqlVector<T> but never uses T, so callers write SqlVector<float>.ConvertPayloadElementType(...), which reads as though it returns a float32 result.
• On .NET Framework the reader surfaces a float16 column as string while an output parameter surfaces it as SqlVector<float>. Self-consistent, but worth documenting.
• Preprocessor directives in the new code are indented to the surrounding block; the dominant style in these files is column 0.
• ConnectionCapabilities.cs:179 says vectors were "introduced in SQL Server 2022" — pre-existing, but the new Float16VectorType doc sits right beside it.
• Worth confirming the doc/samples build resolves the locally-packed driver: SqlVectorFloat16Example.cs references SqlVector<Half> and GetSqlVector<Half>, which exist in no released package.

_{Review assisted by GitHub Copilot; findings verified against the code at a5de733c3.}

[saurabh500]

@apoorvdeshmukh and @cheenamalhotra, I think we will need to call this API a known limitation for preventing backward migration from .Net Runtime to NetFx.

I believe this is a known reasonable compromise.

[saurabh500]

BTW, I saw changes to ref assembly. Should I expect two copies of changes, one for netcore and another for NetFx? I am curious about how the APIs will show up in contract assemblies targeting 2 different frameworks.

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

Note

This error may be related to your runner configuration. You can now configure runners for Copilot code review separately from Copilot cloud agent by creating a copilot-code-review.yml file with your setup steps. Read the docs for details.

[apoorvdeshmukh]

Clarify float16 output parameter type versus JSON reader contract

I clarified the comment and V2 docs in e1e4757. Reader columns and output bindings are separate: on Framework, a float32 vector binding returns SqlVector, while varchar(max) returns string/SqlString for non-null output. The existing sync/async and null-output tests pass on net462 and net10.0; no returned types changed.

[Copilot]

🔵 Needs a closer look

Human assessment is needed because an unverified edge case may cause bulk copies from native vector sources to text destinations to fail.

1 open issue

• Avoid object-column type inference from null first rows

1 resolved since last review

• This shared XML snippet is included when building the .NET Framework target, but System.Half does…

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[Copilot]

🟡 Changes recommended

The implementation still has critical vector bulk-copy bugs that can consume sequential readers and misclassify later native vector values after a leading null.

2 open issues

• Avoid consuming sequential reader rows during vector metadata analysis · New
• Avoid object-column type inference from null first rows

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[Copilot]

🟡 Changes recommended

Active issues remain, including a critical NullReferenceException in vector bulk-copy metadata analysis and a documented default mismatch that must be resolved.

2 open issues

• Avoid dereferencing the current row during bulk metadata analysis · New
• Align documented default with the implemented vector type default · New

2 resolved since last review

• Avoid consuming sequential reader rows during vector metadata analysis
• Avoid object-column type inference from null first rows

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[Copilot]

🔵 Needs a closer look

A critical hidden edge case in vector dimension inference can produce inconsistent metadata and payloads during bulk copy, so human assessment is needed.

No open issues 🎉

2 resolved since last review

• Avoid dereferencing the current row during bulk metadata analysis
• Align documented default with the implemented vector type default

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[cheenamalhotra]

Review summary

Scope: Full re-review at b2f1e688, compared with mssql-jdbc (579528968) and the JDBC vector docs.

What this PR does: Adds vector(n, float16) support, a new Vector Type Support keyword (Off/V1/V2, default V2), SqlVector<Half> on .NET, float16 to float32 widening, and bulk copy/schema updates.

Existing feedback: All 91 earlier threads are resolved. I am not repeating them.

New findings

#	Severity	Area	Summary
1	P2	Bulk copy	A typed SqlVector<T> value from a non-SqlClient reader fails when the destination is text (inline)

Breaking behavior (please confirm it is intended)

• Default is now V2. On .NET, GetValue/GetFieldType/schema return SqlVector<Half> for float16 columns, where they used to return a JSON string. Apps that cast to string will break. Vector Type Support=V1 restores the old behavior. Please call this out in the release notes.
• Public API changes are additive only: the SqlVectorTypeSupport enum and SqlConnectionStringBuilder.VectorTypeSupport. The SqlVector<T> signatures match 7.1.1.

Gaps vs JDBC: intentional or accidental?

@apoorvdeshmukh, please confirm each item, and add a doc note for the intentional ones.

#	JDBC	This PR	Question
1	Default vectorTypeSupport=v1	Default V2	Intentional? (see inline)
2	Rejects FLOAT16 writes on the client under v1/off, including TVP	Sends the value to the server; the server error surfaces	Intentional?
3	Narrows Float[] to binary16 on write	No float to Half encoder; typed float16 writes need SqlVector<Half> (.NET only)	Intentional? How do .NET Framework users write native float16?
4	Vector TVP columns supported	SqlMetaData rejects SqlDbTypeExtensions.Vector (pre-existing)	Planned follow-up?
5	One Vector type with Float[] on all runtimes	SqlVector<Half> on .NET; string/SqlString by default on .NET Framework	Intentional?
6	n/a	Wide float16 (1999-3996 dims) read as SqlVector<float> cannot be written back natively	Already discussed; please document it

Azure SQL DB coverage

I checked build 187133. Float16 manual tests run and pass on Azure SQL DB. For example, Win25_Azure_Sql net10 (run 3630674) and net462 (run 3630747) pass VectorFloat16BehaviourTests, NativeVectorFloat16Tests, and NativeVectorFloat16AsSingleTests.
On the on-prem legs (Win22_Sql19, Win25_Sql25, named instance, x86), every float16 test is skipped, because CheckVectorFloat16Supported returns false there.

Coverage request: The probe hides every SqlException, so a broken Azure config would also skip silently and the build would stay green. Consider failing, or at least logging the reason, when the target is Azure SQL and the probe fails.

Tests run locally (macOS, net10.0)

• Unit: FullyQualifiedName~Vector|FullyQualifiedName~Float16Converter: 79 passed
• Functional: SqlConnectionStringBuilderTest VectorTypeSupport: 47 passed

[apoorvdeshmukh]

Please confirm each item, and add a doc note for the intentional ones.

1. Default V2: intentional for 8.0. The PR now includes a suggested breaking-change release note with Vector Type Support=V1 as the compatibility workaround.
2. Outgoing writes under V1/Off: intentional. The keyword selects requested result representation; unsupported outgoing writes remain server errors rather than new client-side gates.
3. Framework writes: send SqlVector<float> (up to 1,998 elements) or a JSON string bound as varchar(max); SQL Server converts to the destination's float16 base type. There is no Framework SqlVector<Half> or client-side narrowing encoder.
4. TVPs: vector TVP support is not part of this change. The existing SqlMetaData limitation is now documented; this does not commit to a separate implementation or schedule.
5. Framework reads: intentional. Reader results use string/SqlString, with exact widening available through GetSqlVector<float>; output-parameter bindings remain a separate contract.
6. Wide values: the existing docs specify the 1,998-element native float32 write limit and JSON varchar(max) for wider float16 writes, up to 3,996 elements.

For the coverage request, 5974f10 adds SQL error number, state, and severity to failed float16-probe diagnostics without logging connection details. The probe still treats unavailable capability as a skip; I have not changed CI's expected-capability policy. A missing-database regression failed before the diagnostic was added and passes on net462/net10.0; the combined probe/bulk-source run passed 33/58 cases with no skips.

Update after the scope review (53d8e46): the implicit reader-to-text fallback from e98526b has been withdrawn. Vector-specific bulk metadata is restricted to native vector destinations; supply JSON strings for text destinations. Existing string-valued paths, including Framework float16 projections, keep their ordinary conversion behavior. Optional GetFieldType failures (NotImplementedException/NotSupportedException) preserve legacy reader inputs, and ordinary text copies gain no extra source-metadata calls or row scans. The merged tree passed 1,777 repository tests plus 1,616 local/Azure matrix checks across net462/net10.0. Reference/sample/package builds, Unix-target compilation, and strict source XML passed; strict packaged XML retains only the two known unrelated SqlTriggerContext references.

[Copilot]

🔵 Needs a closer look

A critical active finding remains because bulk metadata discovery can dereference a null _currentRow, causing a NullReferenceException for vector-backed in-memory sources before copying begins.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[cheenamalhotra]

Thanks @apoorvdeshmukh. I checked the replies against 5974f10de. The docs, the breaking-change release note, and the notes on JDBC differences look good, and the reader-to-text limitation as documented is fine.

Two follow-ups (inline):

1. The new probe log message may not show up in CI logs.
2. The new schema tests failed with a deadlock on Azure SQL net462 in build 187379.

[Copilot]

🔵 Needs a closer look

A critical active defect remains in SqlBulkCopy metadata inference: when the first selected value is DBNull, later SqlVector values can receive incorrect destination metadata, causing valid float16 payloads to be rejected or coerced as text.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[Copilot]

🔵 Needs a closer look

A critical active issue causes the new in-memory bulk-copy path to dereference an uninitialized row and fail with a NullReferenceException before any rows are copied.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[Copilot]

🔵 Needs a closer look

The change spans TDS negotiation, cross-framework vector materialization, reader/output-parameter accessors, and bulk-copy behavior, while validation omits Linux/macOS runtimes, the full package matrix, and native SQL Server scenarios, so maintainer review is warranted.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[apoorvdeshmukh]

CI disposition: Build 187444 is partially succeeded, despite the green GitHub project check.

Confirmed: build 187444 tested merge 46af88c0, whose parents include head ee74c6751. Its failed/succeeded-with-issues tasks are all explicitly non-gating Run Flaky ... Tests steps. Both the TVP test and the MARS test already have category=flaky on the CI base revision, and both files are byte-identical between that base and this head. The flaky-step continueOnError: true policy is likewise identical between base and the CI merge.

I inspected run 3636255 and its flaky-only task log: the TVP test failed its baseline-comparison assertion; MARS failed the session-count assertion with expected 3, actual 2. I have not independently reproduced these failures on base, so this is not a claim that a regression has been ruled out. No matching tracking issue turned up in exact-test-name searches. With no demonstrated vector-path defect, I am leaving these already non-gating diagnostic runs unretried and the tests/pipeline unchanged rather than expanding this PR. The description now explicitly records the partially succeeded build and distinguishes passing GitHub checks from an all-tests-passed claim.

[Copilot]

🔵 Needs a closer look

A critical active finding shows vector coercion incorrectly returns binary data for text destinations, causing the Half cases in the new tests to fail and requiring a code fix.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[apoorvdeshmukh]

A critical active finding shows vector coercion incorrectly returns binary data for text destinations, causing the Half cases in the new tests to fail and requiring a code fix.

This claim in the review overview does not match 53d8e4603. VarChar, NVarChar, and Json all have ClassType == typeof(string), so CoerceValue enters the earlier string-conversion branch and throws the expected InvalidCastException; it cannot reach the later raw-vector-payload else if.

CoerceValue_NativeVectorToText_ThrowsInvalidCastException passed all six float32/Half cases on .NET 10 and all three float32 cases on .NET Framework in the final local run. The underlying finding was already explained and resolved. An exception expected by these tests is not a test failure. If a different scenario is intended, please include the exact failing test and output.

CI follow-up: the integration failures were real, but in a different path: bulk copy's shared XML/JSON case asserted the value type without rejecting a native vector first. Our final local execution coverage was Release-only, where a later writer cast produced the expected exception; Debug instead raised a DebugAssertException. Fixed in 21f8750 by rejecting native vector JSON input at the bulk-copy conversion boundary, without weakening assertions or changing valid JSON/XML handling. The new boundary tests reproduced the defect in both configurations, then all 270 targeted unit/integration checks passed across net462/net10.0 in Debug and Release.

[Copilot]

🔵 Needs a closer look

A critical active finding remains: metadata setup dereferences a null _currentRow for supported DataTable/DataRow[] vector sources, causing a NullReferenceException before any rows are copied.

No open issues 🎉

1 file not reviewed

• src/Microsoft.Data.SqlClient/src/Resources/Strings.Designer.cs: Generated file

_{Review effort: Lite}

[priyankatiwari08]

Looks good — no new concerns beyond existing threads. Partial coverage: core source only (SqlVector, Float16Converter, SqlBuffer, SqlDataReader, SqlCommand, vector negotiation/options); tests/docs skimmed.