From 12cf0b11ef4d24fd76db563790a417722afc9589 Mon Sep 17 00:00:00 2001
From: Edward Neal <55035479+edwardneal@users.noreply.github.com>
Date: Sun, 7 Jun 2026 11:27:43 +0100
Subject: [PATCH 01/26] Move all vector tests to NativeVectorTestsBase.cs
---
...icrosoft.Data.SqlClient.ManualTests.csproj | 1 +
.../VectorTest/NativeVectorFloat32Tests.cs | 623 +----------------
.../SQL/VectorTest/NativeVectorTestsBase.cs | 626 ++++++++++++++++++
3 files changed, 629 insertions(+), 621 deletions(-)
create mode 100644 src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj b/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj
index 83dd4a8351..9ce2c7c0d5 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj
@@ -243,6 +243,7 @@
+
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
index 0a86534112..6911c37492 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
@@ -2,625 +2,6 @@
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Data.SqlTypes;
-using System.Text.Json;
-using System.Threading.Tasks;
-using Microsoft.Data.SqlTypes;
-using Xunit;
-using Xunit.Abstractions;
+namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest;
-namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest
-{
- public static class VectorFloat32TestData
- {
- public const int VectorHeaderSize = 8;
- public static float[] testData = new float[] { 1.1f, 2.2f, 3.3f, 1.01f, float.MinValue, -0.0f };
- public static int vectorColumnLength = testData.Length;
- // Incorrect size for SqlParameter.Size
- public static int IncorrectParamSize = 3234;
- public static IEnumerable GetVectorFloat32TestData()
- {
- // Pattern 1-4 with SqlVector(values: testData)
- yield return new object[] { 1, new SqlVector(testData), testData, vectorColumnLength };
- yield return new object[] { 2, new SqlVector(testData), testData, vectorColumnLength };
- yield return new object[] { 3, new SqlVector(testData), testData, vectorColumnLength };
- yield return new object[] { 4, new SqlVector(testData), testData, vectorColumnLength };
-
- // Pattern 1-4 with SqlVector(n)
- yield return new object[] { 1, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
- yield return new object[] { 2, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
- yield return new object[] { 3, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
- yield return new object[] { 4, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
-
- // Pattern 1-4 with DBNull
- yield return new object[] { 1, DBNull.Value, Array.Empty(), vectorColumnLength };
- yield return new object[] { 2, DBNull.Value, Array.Empty(), vectorColumnLength };
- yield return new object[] { 3, DBNull.Value, Array.Empty(), vectorColumnLength };
- yield return new object[] { 4, DBNull.Value, Array.Empty(), vectorColumnLength };
-
- // Pattern 1-4 with SqlVector.Null
- yield return new object[] { 1, SqlVector.Null, Array.Empty(), vectorColumnLength };
-
- // Following scenario is not supported in SqlClient.
- // This can only be fixed with a behavior change that SqlParameter.Value is internally set to DBNull.Value if it is set to null.
- //yield return new object[] { 2, SqlVector.Null, Array.Empty(), vectorColumnLength };
-
- yield return new object[] { 3, SqlVector.Null, Array.Empty(), vectorColumnLength };
- yield return new object[] { 4, SqlVector.Null, Array.Empty(), vectorColumnLength };
- }
- }
-
- public sealed class NativeVectorFloat32Tests : IDisposable
- {
- private readonly ITestOutputHelper _output;
- private static readonly string s_connectionString = ManualTesting.Tests.DataTestUtility.TCPConnectionString;
- private static readonly string s_tableName = DataTestUtility.GetShortName("VectorTestTable");
- private static readonly string s_bulkCopySrcTableName = DataTestUtility.GetShortName("VectorBulkCopyTestTable");
- private static readonly int s_vectorDimensions = VectorFloat32TestData.vectorColumnLength;
- private static readonly string s_bulkCopySrcTableDef = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
- private static readonly string s_tableDefinition = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
- private static readonly string s_selectCmdString = $"SELECT VectorData FROM {s_tableName} ORDER BY Id DESC";
- private static readonly string s_insertCmdString = $"INSERT INTO {s_tableName} (VectorData) VALUES (@VectorData)";
- private static readonly string s_vectorParamName = $"@VectorData";
- private static readonly string s_outputVectorParamName = $"@OutputVectorData";
- private static readonly string s_storedProcName = DataTestUtility.GetShortName("VectorsAsVarcharSp");
- private static readonly string s_storedProcBody = $@"
- {s_vectorParamName} vector({s_vectorDimensions}), -- Input: Serialized float[] as JSON string
- {s_outputVectorParamName} vector({s_vectorDimensions}) OUTPUT -- Output: Echoed back from latest inserted row
- AS
- BEGIN
- SET NOCOUNT ON;
-
- -- Insert into vector table
- INSERT INTO {s_tableName} (VectorData)
- VALUES ({s_vectorParamName});
-
- -- Retrieve latest entry (assumes auto-incrementing ID)
- SELECT TOP 1 {s_outputVectorParamName} = VectorData
- FROM {s_tableName}
- ORDER BY Id DESC;
- END;";
-
- public NativeVectorFloat32Tests(ITestOutputHelper output)
- {
- _output = output;
- using var connection = new SqlConnection(s_connectionString);
- connection.Open();
- DataTestUtility.CreateTable(connection, s_tableName, s_tableDefinition);
- DataTestUtility.CreateTable(connection, s_bulkCopySrcTableName, s_bulkCopySrcTableDef);
- DataTestUtility.CreateSP(connection, s_storedProcName, s_storedProcBody);
- }
-
- public void Dispose()
- {
- using var connection = new SqlConnection(s_connectionString);
- connection.Open();
- DataTestUtility.DropTable(connection, s_tableName);
- DataTestUtility.DropTable(connection, s_bulkCopySrcTableName);
- DataTestUtility.DropStoredProcedure(connection, s_storedProcName);
- }
-
- private void ValidateSqlVectorFloat32Object(bool isNull, SqlVector sqlVectorFloat32, float[] expectedData, int expectedLength)
- {
- Assert.Equal(expectedData, sqlVectorFloat32.Memory.ToArray());
- Assert.Equal(expectedLength, sqlVectorFloat32.Length);
- if (!isNull)
- {
- Assert.False(sqlVectorFloat32.IsNull, "IsNull set to true for a non-null value");
- }
- else
- {
- Assert.True(sqlVectorFloat32.IsNull, "IsNull set to false for a null value");
- }
- }
-
- private void ValidateInsertedData(SqlConnection connection, float[] expectedData, int expectedLength)
- {
- using var selectCmd = new SqlCommand(s_selectCmdString, connection);
- using var reader = selectCmd.ExecuteReader();
- Assert.True(reader.Read(), "No data found in the table.");
-
- //For both null and non-null cases, validate the SqlVector object
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetSqlVector(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), reader.GetFieldValue>(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetSqlValue(0), expectedData, expectedLength);
-
- if (!reader.IsDBNull(0))
- {
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader[0], expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
- Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
- Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
- Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetFieldValue(0)));
- }
- else
- {
- Assert.Equal(DBNull.Value, reader.GetValue(0));
- Assert.Equal(DBNull.Value, reader[0]);
- Assert.Equal(DBNull.Value, reader["VectorData"]);
- Assert.Throws(() => reader.GetString(0));
- Assert.Throws(() => reader.GetSqlString(0).Value);
- Assert.Throws(() => reader.GetFieldValue(0));
- }
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
- public void TestSqlVectorFloat32ParameterInsertionAndReads(
- int pattern,
- object value,
- float[] expectedValues,
- int expectedLength)
- {
- using var conn = new SqlConnection(s_connectionString);
- conn.Open();
-
- using var insertCmd = new SqlCommand(s_insertCmdString, conn);
-
- SqlParameter param = pattern switch
- {
- 1 => new SqlParameter
- {
- ParameterName = s_vectorParamName,
- SqlDbType = SqlDbTypeExtensions.Vector,
- Value = value
- },
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- // Even if size is specified, the actual size is determined by the value passed and specified size is ignored.
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
- _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
- };
-
- insertCmd.Parameters.Add(param);
- Assert.Equal(1, insertCmd.ExecuteNonQuery());
- insertCmd.Parameters.Clear();
-
- ValidateInsertedData(conn, expectedValues, expectedLength);
- }
-
- private async Task ValidateInsertedDataAsync(SqlConnection connection, float[] expectedData, int expectedLength)
- {
- using var selectCmd = new SqlCommand(s_selectCmdString, connection);
- using var reader = await selectCmd.ExecuteReaderAsync();
- Assert.True(await reader.ReadAsync(), "No data found in the table.");
-
- //For both null and non-null cases, validate the SqlVector object
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetSqlVector(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), await reader.GetFieldValueAsync>(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetSqlValue(0), expectedData, expectedLength);
-
- if (!await reader.IsDBNullAsync(0))
- {
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader[0], expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
- Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
- Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
- Assert.Equal(expectedData, JsonSerializer.Deserialize(await reader.GetFieldValueAsync(0)));
- }
- else
- {
- Assert.Equal(DBNull.Value, reader.GetValue(0));
- Assert.Equal(DBNull.Value, reader[0]);
- Assert.Equal(DBNull.Value, reader["VectorData"]);
- Assert.Throws(() => reader.GetString(0));
- Assert.Throws(() => reader.GetSqlString(0).Value);
- await Assert.ThrowsAsync(async () => await reader.GetFieldValueAsync(0));
- }
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
- public async Task TestSqlVectorFloat32ParameterInsertionAndReadsAsync(
- int pattern,
- object value,
- float[] expectedValues,
- int expectedLength)
- {
- using var conn = new SqlConnection(s_connectionString);
- await conn.OpenAsync();
-
- using var insertCmd = new SqlCommand(s_insertCmdString, conn);
-
- SqlParameter param = pattern switch
- {
- 1 => new SqlParameter
- {
- ParameterName = s_vectorParamName,
- SqlDbType = (SqlDbType)36, // SqlDbTypeExtension.Vector
- Value = value
- },
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
- _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
- };
-
- insertCmd.Parameters.Add(param);
- Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
- insertCmd.Parameters.Clear();
-
- await ValidateInsertedDataAsync(conn, expectedValues, expectedLength);
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
- public void TestStoredProcParamsForVectorFloat32(
- int pattern,
- object value,
- float[] expectedValues,
- int expectedLength)
- {
- //Create SP for test
- using var conn = new SqlConnection(s_connectionString);
- conn.Open();
- DataTestUtility.CreateSP(conn, s_storedProcName, s_storedProcBody);
- using var command = new SqlCommand(s_storedProcName, conn)
- {
- CommandType = CommandType.StoredProcedure
- };
-
- // Set input and output parameters
- SqlParameter inputParam = pattern switch
- {
- 1 => new SqlParameter
- {
- ParameterName = s_vectorParamName,
- SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
- Value = value
- },
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
- _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
- };
- command.Parameters.Add(inputParam);
-
- var outputParam = new SqlParameter
- {
- ParameterName = s_outputVectorParamName,
- SqlDbType = SqlDbTypeExtensions.Vector,
- Direction = ParameterDirection.Output,
- Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
- };
- command.Parameters.Add(outputParam);
-
- // Execute the stored procedure
- command.ExecuteNonQuery();
-
- // Validate the output parameter
- var vector = (SqlVector)outputParam.Value;
- ValidateSqlVectorFloat32Object(vector.IsNull, vector, expectedValues, expectedLength);
-
- // Validate error for conventional way of setting output parameters
- command.Parameters.Clear();
- command.Parameters.Add(inputParam);
- var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
- command.Parameters.Add(outputParamWithoutVal);
- Assert.Throws(() => command.ExecuteNonQuery());
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
- public async Task TestStoredProcParamsForVectorFloat32Async(
- int pattern,
- object value,
- float[] expectedValues,
- int expectedLength)
- {
- //Create SP for test
- using var conn = new SqlConnection(s_connectionString);
- await conn.OpenAsync();
- DataTestUtility.CreateSP(conn, s_storedProcName, s_storedProcBody);
- using var command = new SqlCommand(s_storedProcName, conn)
- {
- CommandType = CommandType.StoredProcedure
- };
-
- // Set input and output parameters
- SqlParameter inputParam = pattern switch
- {
- 1 => new SqlParameter
- {
- ParameterName = s_vectorParamName,
- SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
- Value = value
- },
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
- _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
- };
- command.Parameters.Add(inputParam);
-
- var outputParam = new SqlParameter
- {
- ParameterName = s_outputVectorParamName,
- SqlDbType = SqlDbTypeExtensions.Vector,
- Direction = ParameterDirection.Output,
- Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
- };
- command.Parameters.Add(outputParam);
-
- // Execute the stored procedure
- await command.ExecuteNonQueryAsync();
-
- // Validate the output parameter
- var vector = (SqlVector)outputParam.Value;
- ValidateSqlVectorFloat32Object(vector.IsNull, vector, expectedValues, expectedLength);
-
- // Validate error for conventional way of setting output parameters
- command.Parameters.Clear();
- command.Parameters.Add(inputParam);
- var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
- command.Parameters.Add(outputParamWithoutVal);
- await Assert.ThrowsAsync(async () => await command.ExecuteNonQueryAsync());
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [InlineData(1)]
- [InlineData(2)]
- public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
- {
- //Setup source with test data and create destination table for bulkcopy.
- SqlConnection sourceConnection = new SqlConnection(s_connectionString);
- sourceConnection.Open();
- SqlConnection destinationConnection = new SqlConnection(s_connectionString);
- destinationConnection.Open();
- DataTable table = null;
- switch (bulkCopySourceMode)
- {
-
- case 1:
- // Use SqlServer table as source
- var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
- var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
-
- // Insert 2 rows with one non-null and null value
- insertCmd.Parameters.Add(vectorParam);
- Assert.Equal(1, insertCmd.ExecuteNonQuery());
- insertCmd.Parameters.Clear();
- vectorParam.Value = DBNull.Value;
- insertCmd.Parameters.Add(vectorParam);
- Assert.Equal(1, insertCmd.ExecuteNonQuery());
- insertCmd.Parameters.Clear();
- break;
- case 2:
- table = new DataTable(s_bulkCopySrcTableName);
- table.Columns.Add("Id", typeof(int));
- table.Columns.Add("VectorData", typeof(SqlVector));
- table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
- table.Rows.Add(2, DBNull.Value);
- break;
- default:
- throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
- }
-
-
-
- //Bulkcopy from sql server table to destination table
- using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
- using SqlDataReader reader = sourceDataCommand.ExecuteReader();
-
- // Verify that the destination table is empty before bulk copy
- using SqlCommand countCommand = new SqlCommand($"SELECT COUNT(*) FROM {s_tableName}", destinationConnection);
- Assert.Equal(0, Convert.ToInt16(countCommand.ExecuteScalar()));
-
- // Initialize bulk copy configuration
- using SqlBulkCopy bulkCopy = new SqlBulkCopy(destinationConnection)
- {
- DestinationTableName = s_tableName,
- };
-
- try
- {
- switch (bulkCopySourceMode)
- {
- case 1:
- bulkCopy.WriteToServer(reader);
- break;
- case 2:
- bulkCopy.WriteToServer(table);
- break;
- default:
- throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
- }
- }
- catch (Exception ex)
- {
- // If bulk copy fails, fail the test with the exception message
- Assert.Fail($"Bulk copy failed: {ex.Message}");
- }
-
- // Verify that the 2 rows from the source table have been copied into the destination table.
- Assert.Equal(2, Convert.ToInt16(countCommand.ExecuteScalar()));
-
- // Read the data from destination table as varbinary to verify the UTF-8 byte sequence
- using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
- using SqlDataReader verifyReader = verifyCommand.ExecuteReader();
-
- // Verify that we have data in the destination table
- Assert.True(verifyReader.Read(), "No data found in destination table after bulk copy.");
-
- // Validate first non-null value.
- Assert.True(!verifyReader.IsDBNull(0), "First row in the table is null.");
- Assert.Equal(VectorFloat32TestData.testData, ((SqlVector)verifyReader.GetSqlVector(0)).Memory.ToArray());
- Assert.Equal(VectorFloat32TestData.testData.Length, ((SqlVector)verifyReader.GetSqlVector(0)).Length);
-
- // Verify that we have another row
- Assert.True(verifyReader.Read(), "Second row not found in the table");
-
- // Verify that we have encountered null.
- Assert.True(verifyReader.IsDBNull(0));
- Assert.Equal(Array.Empty(), ((SqlVector)verifyReader.GetSqlVector(0)).Memory.ToArray());
- Assert.Equal(VectorFloat32TestData.testData.Length, ((SqlVector)verifyReader.GetSqlVector(0)).Length);
- }
-
- [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- [InlineData(1)]
- [InlineData(2)]
- public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
- {
- //Setup source with test data and create destination table for bulkcopy.
- SqlConnection sourceConnection = new SqlConnection(s_connectionString);
- await sourceConnection.OpenAsync();
- SqlConnection destinationConnection = new SqlConnection(s_connectionString);
- await destinationConnection.OpenAsync();
-
- DataTable table = null;
- switch (bulkCopySourceMode)
- {
-
- case 1:
- // Use SqlServer table as source
- var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
- var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
-
- // Insert 2 rows with one non-null and null value
- insertCmd.Parameters.Add(vectorParam);
- Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
- insertCmd.Parameters.Clear();
- vectorParam.Value = DBNull.Value;
- insertCmd.Parameters.Add(vectorParam);
- Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
- insertCmd.Parameters.Clear();
- break;
- case 2:
- table = new DataTable(s_bulkCopySrcTableName);
- table.Columns.Add("Id", typeof(int));
- table.Columns.Add("VectorData", typeof(SqlVector));
- table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
- table.Rows.Add(2, DBNull.Value);
- break;
- default:
- throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
- }
-
- //Bulkcopy from sql server table to destination table
- using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
- using SqlDataReader reader = await sourceDataCommand.ExecuteReaderAsync();
-
- // Verify that the destination table is empty before bulk copy
- using SqlCommand countCommand = new SqlCommand($"SELECT COUNT(*) FROM {s_tableName}", destinationConnection);
- Assert.Equal(0, Convert.ToInt16(await countCommand.ExecuteScalarAsync()));
-
- // Initialize bulk copy configuration
- using SqlBulkCopy bulkCopy = new SqlBulkCopy(destinationConnection)
- {
- DestinationTableName = s_tableName,
- };
-
- try
- { // Perform bulkcopy
- switch (bulkCopySourceMode)
- {
- case 1:
- await bulkCopy.WriteToServerAsync(reader);
- break;
- case 2:
- await bulkCopy.WriteToServerAsync(table);
- break;
- default:
- throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
- }
- }
- catch (Exception ex)
- {
- // If bulk copy fails, fail the test with the exception message
- Assert.Fail($"Bulk copy failed: {ex.Message}");
- }
-
- // Verify that the 2 rows from the source table have been copied into the destination table.
- Assert.Equal(2, Convert.ToInt16(await countCommand.ExecuteScalarAsync()));
-
- // Read the data from destination table as varbinary to verify the UTF-8 byte sequence
- using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
- using SqlDataReader verifyReader = await verifyCommand.ExecuteReaderAsync();
-
- // Verify that we have data in the destination table
- Assert.True(await verifyReader.ReadAsync(), "No data found in destination table after bulk copy.");
-
- // Validate first non-null value.
- Assert.True(!await verifyReader.IsDBNullAsync(0), "First row in the table is null.");
- var vector = await verifyReader.GetFieldValueAsync>(0);
- Assert.Equal(VectorFloat32TestData.testData, vector.Memory.ToArray());
- Assert.Equal(VectorFloat32TestData.testData.Length, vector.Length);
-
- // Verify that we have another row
- Assert.True(await verifyReader.ReadAsync(), "Second row not found in the table");
-
- // Verify that we have encountered null.
- Assert.True(await verifyReader.IsDBNullAsync(0));
- vector = await verifyReader.GetFieldValueAsync>(0);
- Assert.Equal(Array.Empty(), vector.Memory.ToArray());
- Assert.Equal(VectorFloat32TestData.testData.Length, vector.Length);
- }
-
- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- public void TestGetFieldTypeReturnsSqlVectorForVectorColumn()
- {
- using var connection = new SqlConnection(s_connectionString);
- connection.Open();
-
- // Insert a row so we can query it
- using (var insertCmd = new SqlCommand(s_insertCmdString, connection))
- {
- var param = insertCmd.Parameters.Add(s_vectorParamName, SqlDbTypeExtensions.Vector);
- param.Value = new SqlVector(VectorFloat32TestData.testData);
- insertCmd.ExecuteNonQuery();
- }
-
- using var selectCmd = new SqlCommand(s_selectCmdString, connection);
- using var reader = selectCmd.ExecuteReader();
-
- // Verify GetFieldType returns SqlVector for the vector column
- Assert.Equal(typeof(SqlVector), reader.GetFieldType(0));
-
- // Verify GetProviderSpecificFieldType also returns SqlVector
- Assert.Equal(typeof(SqlVector), reader.GetProviderSpecificFieldType(0));
-
- // Verify that GetValue returns an instance consistent with GetFieldType
- Assert.True(reader.Read(), "No data found in the table.");
- object value = reader.GetValue(0);
- Assert.IsType>(value);
- Assert.Equal(VectorFloat32TestData.testData, ((SqlVector)value).Memory.ToArray());
-
- // Verify GetFieldValue> returns the correct typed value
- SqlVector typedValue = reader.GetFieldValue>(0);
- Assert.IsType>(typedValue);
- Assert.Equal(VectorFloat32TestData.testData, typedValue.Memory.ToArray());
- }
-
- [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
- public void TestInsertVectorsFloat32WithPrepare()
- {
- SqlConnection conn = new SqlConnection(s_connectionString);
- conn.Open();
- SqlCommand command = new SqlCommand(s_insertCmdString, conn);
- SqlParameter vectorParam = new SqlParameter("@VectorData", SqlDbTypeExtensions.Vector);
- command.Parameters.Add(vectorParam);
- command.Prepare();
- for (int i = 0; i < 10; i++)
- {
- vectorParam.Value = new SqlVector(new float[] { i + 0.1f, i + 0.2f, i + 0.3f, i + 0.4f, i + 0.5f, i + 0.6f });
- command.ExecuteNonQuery();
- }
- SqlCommand validateCommand = new SqlCommand($"SELECT VectorData FROM {s_tableName}", conn);
- using SqlDataReader reader = validateCommand.ExecuteReader();
- int rowcnt = 0;
- while (reader.Read())
- {
- float[] expectedData = new float[] { rowcnt + 0.1f, rowcnt + 0.2f, rowcnt + 0.3f, rowcnt + 0.4f, rowcnt + 0.5f, rowcnt + 0.6f };
- float[] dbData = reader.GetSqlVector(0).Memory.ToArray();
- Assert.Equal(expectedData, dbData);
- rowcnt++;
- }
- Assert.Equal(10, rowcnt);
- }
- }
-}
+#nullable enable
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
new file mode 100644
index 0000000000..0a86534112
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
@@ -0,0 +1,626 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlTypes;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Data.SqlTypes;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest
+{
+ public static class VectorFloat32TestData
+ {
+ public const int VectorHeaderSize = 8;
+ public static float[] testData = new float[] { 1.1f, 2.2f, 3.3f, 1.01f, float.MinValue, -0.0f };
+ public static int vectorColumnLength = testData.Length;
+ // Incorrect size for SqlParameter.Size
+ public static int IncorrectParamSize = 3234;
+ public static IEnumerable GetVectorFloat32TestData()
+ {
+ // Pattern 1-4 with SqlVector(values: testData)
+ yield return new object[] { 1, new SqlVector(testData), testData, vectorColumnLength };
+ yield return new object[] { 2, new SqlVector(testData), testData, vectorColumnLength };
+ yield return new object[] { 3, new SqlVector(testData), testData, vectorColumnLength };
+ yield return new object[] { 4, new SqlVector(testData), testData, vectorColumnLength };
+
+ // Pattern 1-4 with SqlVector(n)
+ yield return new object[] { 1, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
+ yield return new object[] { 2, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
+ yield return new object[] { 3, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
+ yield return new object[] { 4, SqlVector.CreateNull(vectorColumnLength), Array.Empty(), vectorColumnLength };
+
+ // Pattern 1-4 with DBNull
+ yield return new object[] { 1, DBNull.Value, Array.Empty(), vectorColumnLength };
+ yield return new object[] { 2, DBNull.Value, Array.Empty(), vectorColumnLength };
+ yield return new object[] { 3, DBNull.Value, Array.Empty(), vectorColumnLength };
+ yield return new object[] { 4, DBNull.Value, Array.Empty(), vectorColumnLength };
+
+ // Pattern 1-4 with SqlVector.Null
+ yield return new object[] { 1, SqlVector.Null, Array.Empty(), vectorColumnLength };
+
+ // Following scenario is not supported in SqlClient.
+ // This can only be fixed with a behavior change that SqlParameter.Value is internally set to DBNull.Value if it is set to null.
+ //yield return new object[] { 2, SqlVector.Null, Array.Empty(), vectorColumnLength };
+
+ yield return new object[] { 3, SqlVector.Null, Array.Empty(), vectorColumnLength };
+ yield return new object[] { 4, SqlVector.Null, Array.Empty(), vectorColumnLength };
+ }
+ }
+
+ public sealed class NativeVectorFloat32Tests : IDisposable
+ {
+ private readonly ITestOutputHelper _output;
+ private static readonly string s_connectionString = ManualTesting.Tests.DataTestUtility.TCPConnectionString;
+ private static readonly string s_tableName = DataTestUtility.GetShortName("VectorTestTable");
+ private static readonly string s_bulkCopySrcTableName = DataTestUtility.GetShortName("VectorBulkCopyTestTable");
+ private static readonly int s_vectorDimensions = VectorFloat32TestData.vectorColumnLength;
+ private static readonly string s_bulkCopySrcTableDef = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
+ private static readonly string s_tableDefinition = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
+ private static readonly string s_selectCmdString = $"SELECT VectorData FROM {s_tableName} ORDER BY Id DESC";
+ private static readonly string s_insertCmdString = $"INSERT INTO {s_tableName} (VectorData) VALUES (@VectorData)";
+ private static readonly string s_vectorParamName = $"@VectorData";
+ private static readonly string s_outputVectorParamName = $"@OutputVectorData";
+ private static readonly string s_storedProcName = DataTestUtility.GetShortName("VectorsAsVarcharSp");
+ private static readonly string s_storedProcBody = $@"
+ {s_vectorParamName} vector({s_vectorDimensions}), -- Input: Serialized float[] as JSON string
+ {s_outputVectorParamName} vector({s_vectorDimensions}) OUTPUT -- Output: Echoed back from latest inserted row
+ AS
+ BEGIN
+ SET NOCOUNT ON;
+
+ -- Insert into vector table
+ INSERT INTO {s_tableName} (VectorData)
+ VALUES ({s_vectorParamName});
+
+ -- Retrieve latest entry (assumes auto-incrementing ID)
+ SELECT TOP 1 {s_outputVectorParamName} = VectorData
+ FROM {s_tableName}
+ ORDER BY Id DESC;
+ END;";
+
+ public NativeVectorFloat32Tests(ITestOutputHelper output)
+ {
+ _output = output;
+ using var connection = new SqlConnection(s_connectionString);
+ connection.Open();
+ DataTestUtility.CreateTable(connection, s_tableName, s_tableDefinition);
+ DataTestUtility.CreateTable(connection, s_bulkCopySrcTableName, s_bulkCopySrcTableDef);
+ DataTestUtility.CreateSP(connection, s_storedProcName, s_storedProcBody);
+ }
+
+ public void Dispose()
+ {
+ using var connection = new SqlConnection(s_connectionString);
+ connection.Open();
+ DataTestUtility.DropTable(connection, s_tableName);
+ DataTestUtility.DropTable(connection, s_bulkCopySrcTableName);
+ DataTestUtility.DropStoredProcedure(connection, s_storedProcName);
+ }
+
+ private void ValidateSqlVectorFloat32Object(bool isNull, SqlVector sqlVectorFloat32, float[] expectedData, int expectedLength)
+ {
+ Assert.Equal(expectedData, sqlVectorFloat32.Memory.ToArray());
+ Assert.Equal(expectedLength, sqlVectorFloat32.Length);
+ if (!isNull)
+ {
+ Assert.False(sqlVectorFloat32.IsNull, "IsNull set to true for a non-null value");
+ }
+ else
+ {
+ Assert.True(sqlVectorFloat32.IsNull, "IsNull set to false for a null value");
+ }
+ }
+
+ private void ValidateInsertedData(SqlConnection connection, float[] expectedData, int expectedLength)
+ {
+ using var selectCmd = new SqlCommand(s_selectCmdString, connection);
+ using var reader = selectCmd.ExecuteReader();
+ Assert.True(reader.Read(), "No data found in the table.");
+
+ //For both null and non-null cases, validate the SqlVector object
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetSqlVector(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), reader.GetFieldValue>(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetSqlValue(0), expectedData, expectedLength);
+
+ if (!reader.IsDBNull(0))
+ {
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader[0], expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetFieldValue(0)));
+ }
+ else
+ {
+ Assert.Equal(DBNull.Value, reader.GetValue(0));
+ Assert.Equal(DBNull.Value, reader[0]);
+ Assert.Equal(DBNull.Value, reader["VectorData"]);
+ Assert.Throws(() => reader.GetString(0));
+ Assert.Throws(() => reader.GetSqlString(0).Value);
+ Assert.Throws(() => reader.GetFieldValue(0));
+ }
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
+ public void TestSqlVectorFloat32ParameterInsertionAndReads(
+ int pattern,
+ object value,
+ float[] expectedValues,
+ int expectedLength)
+ {
+ using var conn = new SqlConnection(s_connectionString);
+ conn.Open();
+
+ using var insertCmd = new SqlCommand(s_insertCmdString, conn);
+
+ SqlParameter param = pattern switch
+ {
+ 1 => new SqlParameter
+ {
+ ParameterName = s_vectorParamName,
+ SqlDbType = SqlDbTypeExtensions.Vector,
+ Value = value
+ },
+ 2 => new SqlParameter(s_vectorParamName, value),
+ 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
+ // Even if size is specified, the actual size is determined by the value passed and specified size is ignored.
+ 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
+ };
+
+ insertCmd.Parameters.Add(param);
+ Assert.Equal(1, insertCmd.ExecuteNonQuery());
+ insertCmd.Parameters.Clear();
+
+ ValidateInsertedData(conn, expectedValues, expectedLength);
+ }
+
+ private async Task ValidateInsertedDataAsync(SqlConnection connection, float[] expectedData, int expectedLength)
+ {
+ using var selectCmd = new SqlCommand(s_selectCmdString, connection);
+ using var reader = await selectCmd.ExecuteReaderAsync();
+ Assert.True(await reader.ReadAsync(), "No data found in the table.");
+
+ //For both null and non-null cases, validate the SqlVector object
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetSqlVector(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), await reader.GetFieldValueAsync>(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetSqlValue(0), expectedData, expectedLength);
+
+ if (!await reader.IsDBNullAsync(0))
+ {
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader[0], expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
+ Assert.Equal(expectedData, JsonSerializer.Deserialize(await reader.GetFieldValueAsync(0)));
+ }
+ else
+ {
+ Assert.Equal(DBNull.Value, reader.GetValue(0));
+ Assert.Equal(DBNull.Value, reader[0]);
+ Assert.Equal(DBNull.Value, reader["VectorData"]);
+ Assert.Throws(() => reader.GetString(0));
+ Assert.Throws(() => reader.GetSqlString(0).Value);
+ await Assert.ThrowsAsync(async () => await reader.GetFieldValueAsync(0));
+ }
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
+ public async Task TestSqlVectorFloat32ParameterInsertionAndReadsAsync(
+ int pattern,
+ object value,
+ float[] expectedValues,
+ int expectedLength)
+ {
+ using var conn = new SqlConnection(s_connectionString);
+ await conn.OpenAsync();
+
+ using var insertCmd = new SqlCommand(s_insertCmdString, conn);
+
+ SqlParameter param = pattern switch
+ {
+ 1 => new SqlParameter
+ {
+ ParameterName = s_vectorParamName,
+ SqlDbType = (SqlDbType)36, // SqlDbTypeExtension.Vector
+ Value = value
+ },
+ 2 => new SqlParameter(s_vectorParamName, value),
+ 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
+ };
+
+ insertCmd.Parameters.Add(param);
+ Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
+ insertCmd.Parameters.Clear();
+
+ await ValidateInsertedDataAsync(conn, expectedValues, expectedLength);
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
+ public void TestStoredProcParamsForVectorFloat32(
+ int pattern,
+ object value,
+ float[] expectedValues,
+ int expectedLength)
+ {
+ //Create SP for test
+ using var conn = new SqlConnection(s_connectionString);
+ conn.Open();
+ DataTestUtility.CreateSP(conn, s_storedProcName, s_storedProcBody);
+ using var command = new SqlCommand(s_storedProcName, conn)
+ {
+ CommandType = CommandType.StoredProcedure
+ };
+
+ // Set input and output parameters
+ SqlParameter inputParam = pattern switch
+ {
+ 1 => new SqlParameter
+ {
+ ParameterName = s_vectorParamName,
+ SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
+ Value = value
+ },
+ 2 => new SqlParameter(s_vectorParamName, value),
+ 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
+ };
+ command.Parameters.Add(inputParam);
+
+ var outputParam = new SqlParameter
+ {
+ ParameterName = s_outputVectorParamName,
+ SqlDbType = SqlDbTypeExtensions.Vector,
+ Direction = ParameterDirection.Output,
+ Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
+ };
+ command.Parameters.Add(outputParam);
+
+ // Execute the stored procedure
+ command.ExecuteNonQuery();
+
+ // Validate the output parameter
+ var vector = (SqlVector)outputParam.Value;
+ ValidateSqlVectorFloat32Object(vector.IsNull, vector, expectedValues, expectedLength);
+
+ // Validate error for conventional way of setting output parameters
+ command.Parameters.Clear();
+ command.Parameters.Add(inputParam);
+ var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
+ command.Parameters.Add(outputParamWithoutVal);
+ Assert.Throws(() => command.ExecuteNonQuery());
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [MemberData(nameof(VectorFloat32TestData.GetVectorFloat32TestData), MemberType = typeof(VectorFloat32TestData), DisableDiscoveryEnumeration = true)]
+ public async Task TestStoredProcParamsForVectorFloat32Async(
+ int pattern,
+ object value,
+ float[] expectedValues,
+ int expectedLength)
+ {
+ //Create SP for test
+ using var conn = new SqlConnection(s_connectionString);
+ await conn.OpenAsync();
+ DataTestUtility.CreateSP(conn, s_storedProcName, s_storedProcBody);
+ using var command = new SqlCommand(s_storedProcName, conn)
+ {
+ CommandType = CommandType.StoredProcedure
+ };
+
+ // Set input and output parameters
+ SqlParameter inputParam = pattern switch
+ {
+ 1 => new SqlParameter
+ {
+ ParameterName = s_vectorParamName,
+ SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
+ Value = value
+ },
+ 2 => new SqlParameter(s_vectorParamName, value),
+ 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ _ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
+ };
+ command.Parameters.Add(inputParam);
+
+ var outputParam = new SqlParameter
+ {
+ ParameterName = s_outputVectorParamName,
+ SqlDbType = SqlDbTypeExtensions.Vector,
+ Direction = ParameterDirection.Output,
+ Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
+ };
+ command.Parameters.Add(outputParam);
+
+ // Execute the stored procedure
+ await command.ExecuteNonQueryAsync();
+
+ // Validate the output parameter
+ var vector = (SqlVector)outputParam.Value;
+ ValidateSqlVectorFloat32Object(vector.IsNull, vector, expectedValues, expectedLength);
+
+ // Validate error for conventional way of setting output parameters
+ command.Parameters.Clear();
+ command.Parameters.Add(inputParam);
+ var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
+ command.Parameters.Add(outputParamWithoutVal);
+ await Assert.ThrowsAsync(async () => await command.ExecuteNonQueryAsync());
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [InlineData(1)]
+ [InlineData(2)]
+ public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
+ {
+ //Setup source with test data and create destination table for bulkcopy.
+ SqlConnection sourceConnection = new SqlConnection(s_connectionString);
+ sourceConnection.Open();
+ SqlConnection destinationConnection = new SqlConnection(s_connectionString);
+ destinationConnection.Open();
+ DataTable table = null;
+ switch (bulkCopySourceMode)
+ {
+
+ case 1:
+ // Use SqlServer table as source
+ var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
+ var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
+
+ // Insert 2 rows with one non-null and null value
+ insertCmd.Parameters.Add(vectorParam);
+ Assert.Equal(1, insertCmd.ExecuteNonQuery());
+ insertCmd.Parameters.Clear();
+ vectorParam.Value = DBNull.Value;
+ insertCmd.Parameters.Add(vectorParam);
+ Assert.Equal(1, insertCmd.ExecuteNonQuery());
+ insertCmd.Parameters.Clear();
+ break;
+ case 2:
+ table = new DataTable(s_bulkCopySrcTableName);
+ table.Columns.Add("Id", typeof(int));
+ table.Columns.Add("VectorData", typeof(SqlVector));
+ table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
+ table.Rows.Add(2, DBNull.Value);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
+ }
+
+
+
+ //Bulkcopy from sql server table to destination table
+ using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
+ using SqlDataReader reader = sourceDataCommand.ExecuteReader();
+
+ // Verify that the destination table is empty before bulk copy
+ using SqlCommand countCommand = new SqlCommand($"SELECT COUNT(*) FROM {s_tableName}", destinationConnection);
+ Assert.Equal(0, Convert.ToInt16(countCommand.ExecuteScalar()));
+
+ // Initialize bulk copy configuration
+ using SqlBulkCopy bulkCopy = new SqlBulkCopy(destinationConnection)
+ {
+ DestinationTableName = s_tableName,
+ };
+
+ try
+ {
+ switch (bulkCopySourceMode)
+ {
+ case 1:
+ bulkCopy.WriteToServer(reader);
+ break;
+ case 2:
+ bulkCopy.WriteToServer(table);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
+ }
+ }
+ catch (Exception ex)
+ {
+ // If bulk copy fails, fail the test with the exception message
+ Assert.Fail($"Bulk copy failed: {ex.Message}");
+ }
+
+ // Verify that the 2 rows from the source table have been copied into the destination table.
+ Assert.Equal(2, Convert.ToInt16(countCommand.ExecuteScalar()));
+
+ // Read the data from destination table as varbinary to verify the UTF-8 byte sequence
+ using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
+ using SqlDataReader verifyReader = verifyCommand.ExecuteReader();
+
+ // Verify that we have data in the destination table
+ Assert.True(verifyReader.Read(), "No data found in destination table after bulk copy.");
+
+ // Validate first non-null value.
+ Assert.True(!verifyReader.IsDBNull(0), "First row in the table is null.");
+ Assert.Equal(VectorFloat32TestData.testData, ((SqlVector)verifyReader.GetSqlVector(0)).Memory.ToArray());
+ Assert.Equal(VectorFloat32TestData.testData.Length, ((SqlVector)verifyReader.GetSqlVector(0)).Length);
+
+ // Verify that we have another row
+ Assert.True(verifyReader.Read(), "Second row not found in the table");
+
+ // Verify that we have encountered null.
+ Assert.True(verifyReader.IsDBNull(0));
+ Assert.Equal(Array.Empty(), ((SqlVector)verifyReader.GetSqlVector(0)).Memory.ToArray());
+ Assert.Equal(VectorFloat32TestData.testData.Length, ((SqlVector)verifyReader.GetSqlVector(0)).Length);
+ }
+
+ [ConditionalTheory(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ [InlineData(1)]
+ [InlineData(2)]
+ public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
+ {
+ //Setup source with test data and create destination table for bulkcopy.
+ SqlConnection sourceConnection = new SqlConnection(s_connectionString);
+ await sourceConnection.OpenAsync();
+ SqlConnection destinationConnection = new SqlConnection(s_connectionString);
+ await destinationConnection.OpenAsync();
+
+ DataTable table = null;
+ switch (bulkCopySourceMode)
+ {
+
+ case 1:
+ // Use SqlServer table as source
+ var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
+ var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
+
+ // Insert 2 rows with one non-null and null value
+ insertCmd.Parameters.Add(vectorParam);
+ Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
+ insertCmd.Parameters.Clear();
+ vectorParam.Value = DBNull.Value;
+ insertCmd.Parameters.Add(vectorParam);
+ Assert.Equal(1, await insertCmd.ExecuteNonQueryAsync());
+ insertCmd.Parameters.Clear();
+ break;
+ case 2:
+ table = new DataTable(s_bulkCopySrcTableName);
+ table.Columns.Add("Id", typeof(int));
+ table.Columns.Add("VectorData", typeof(SqlVector));
+ table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
+ table.Rows.Add(2, DBNull.Value);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
+ }
+
+ //Bulkcopy from sql server table to destination table
+ using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
+ using SqlDataReader reader = await sourceDataCommand.ExecuteReaderAsync();
+
+ // Verify that the destination table is empty before bulk copy
+ using SqlCommand countCommand = new SqlCommand($"SELECT COUNT(*) FROM {s_tableName}", destinationConnection);
+ Assert.Equal(0, Convert.ToInt16(await countCommand.ExecuteScalarAsync()));
+
+ // Initialize bulk copy configuration
+ using SqlBulkCopy bulkCopy = new SqlBulkCopy(destinationConnection)
+ {
+ DestinationTableName = s_tableName,
+ };
+
+ try
+ { // Perform bulkcopy
+ switch (bulkCopySourceMode)
+ {
+ case 1:
+ await bulkCopy.WriteToServerAsync(reader);
+ break;
+ case 2:
+ await bulkCopy.WriteToServerAsync(table);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException(nameof(bulkCopySourceMode), $"Unsupported bulk copy source mode: {bulkCopySourceMode}");
+ }
+ }
+ catch (Exception ex)
+ {
+ // If bulk copy fails, fail the test with the exception message
+ Assert.Fail($"Bulk copy failed: {ex.Message}");
+ }
+
+ // Verify that the 2 rows from the source table have been copied into the destination table.
+ Assert.Equal(2, Convert.ToInt16(await countCommand.ExecuteScalarAsync()));
+
+ // Read the data from destination table as varbinary to verify the UTF-8 byte sequence
+ using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
+ using SqlDataReader verifyReader = await verifyCommand.ExecuteReaderAsync();
+
+ // Verify that we have data in the destination table
+ Assert.True(await verifyReader.ReadAsync(), "No data found in destination table after bulk copy.");
+
+ // Validate first non-null value.
+ Assert.True(!await verifyReader.IsDBNullAsync(0), "First row in the table is null.");
+ var vector = await verifyReader.GetFieldValueAsync>(0);
+ Assert.Equal(VectorFloat32TestData.testData, vector.Memory.ToArray());
+ Assert.Equal(VectorFloat32TestData.testData.Length, vector.Length);
+
+ // Verify that we have another row
+ Assert.True(await verifyReader.ReadAsync(), "Second row not found in the table");
+
+ // Verify that we have encountered null.
+ Assert.True(await verifyReader.IsDBNullAsync(0));
+ vector = await verifyReader.GetFieldValueAsync>(0);
+ Assert.Equal(Array.Empty(), vector.Memory.ToArray());
+ Assert.Equal(VectorFloat32TestData.testData.Length, vector.Length);
+ }
+
+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ public void TestGetFieldTypeReturnsSqlVectorForVectorColumn()
+ {
+ using var connection = new SqlConnection(s_connectionString);
+ connection.Open();
+
+ // Insert a row so we can query it
+ using (var insertCmd = new SqlCommand(s_insertCmdString, connection))
+ {
+ var param = insertCmd.Parameters.Add(s_vectorParamName, SqlDbTypeExtensions.Vector);
+ param.Value = new SqlVector(VectorFloat32TestData.testData);
+ insertCmd.ExecuteNonQuery();
+ }
+
+ using var selectCmd = new SqlCommand(s_selectCmdString, connection);
+ using var reader = selectCmd.ExecuteReader();
+
+ // Verify GetFieldType returns SqlVector for the vector column
+ Assert.Equal(typeof(SqlVector), reader.GetFieldType(0));
+
+ // Verify GetProviderSpecificFieldType also returns SqlVector
+ Assert.Equal(typeof(SqlVector), reader.GetProviderSpecificFieldType(0));
+
+ // Verify that GetValue returns an instance consistent with GetFieldType
+ Assert.True(reader.Read(), "No data found in the table.");
+ object value = reader.GetValue(0);
+ Assert.IsType>(value);
+ Assert.Equal(VectorFloat32TestData.testData, ((SqlVector)value).Memory.ToArray());
+
+ // Verify GetFieldValue> returns the correct typed value
+ SqlVector typedValue = reader.GetFieldValue>(0);
+ Assert.IsType>(typedValue);
+ Assert.Equal(VectorFloat32TestData.testData, typedValue.Memory.ToArray());
+ }
+
+ [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.IsSqlVectorSupported))]
+ public void TestInsertVectorsFloat32WithPrepare()
+ {
+ SqlConnection conn = new SqlConnection(s_connectionString);
+ conn.Open();
+ SqlCommand command = new SqlCommand(s_insertCmdString, conn);
+ SqlParameter vectorParam = new SqlParameter("@VectorData", SqlDbTypeExtensions.Vector);
+ command.Parameters.Add(vectorParam);
+ command.Prepare();
+ for (int i = 0; i < 10; i++)
+ {
+ vectorParam.Value = new SqlVector(new float[] { i + 0.1f, i + 0.2f, i + 0.3f, i + 0.4f, i + 0.5f, i + 0.6f });
+ command.ExecuteNonQuery();
+ }
+ SqlCommand validateCommand = new SqlCommand($"SELECT VectorData FROM {s_tableName}", conn);
+ using SqlDataReader reader = validateCommand.ExecuteReader();
+ int rowcnt = 0;
+ while (reader.Read())
+ {
+ float[] expectedData = new float[] { rowcnt + 0.1f, rowcnt + 0.2f, rowcnt + 0.3f, rowcnt + 0.4f, rowcnt + 0.5f, rowcnt + 0.6f };
+ float[] dbData = reader.GetSqlVector(0).Memory.ToArray();
+ Assert.Equal(expectedData, dbData);
+ rowcnt++;
+ }
+ Assert.Equal(10, rowcnt);
+ }
+ }
+}
From 7ec73b7b0a9edd73f120c7f2ff7661b4a9701865 Mon Sep 17 00:00:00 2001
From: Edward Neal <55035479+edwardneal@users.noreply.github.com>
Date: Sun, 7 Jun 2026 11:36:12 +0100
Subject: [PATCH 02/26] Refactor to enable base class for float32 vector tests
---
.../SQL/VectorTest/NativeVectorFloat32Tests.cs | 8 ++++++++
.../SQL/VectorTest/NativeVectorTestsBase.cs | 11 ++++++-----
2 files changed, 14 insertions(+), 5 deletions(-)
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
index 6911c37492..ce5ff05732 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
@@ -5,3 +5,11 @@
namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest;
#nullable enable
+
+public sealed class VectorFloat32TestData : VectorTestDataBase
+{
+}
+
+public sealed class NativeVectorFloat32Tests : NativeVectorTestsBase
+{
+}
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
index 0a86534112..be55c939fc 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
@@ -14,7 +14,8 @@
namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest
{
- public static class VectorFloat32TestData
+ public abstract class VectorTestDataBase
+ where TElement : unmanaged
{
public const int VectorHeaderSize = 8;
public static float[] testData = new float[] { 1.1f, 2.2f, 3.3f, 1.01f, float.MinValue, -0.0f };
@@ -53,9 +54,10 @@ public static IEnumerable GetVectorFloat32TestData()
}
}
- public sealed class NativeVectorFloat32Tests : IDisposable
+ public abstract class NativeVectorTestsBase : IDisposable
+ where TElement : unmanaged
+ where TTestData : VectorTestDataBase
{
- private readonly ITestOutputHelper _output;
private static readonly string s_connectionString = ManualTesting.Tests.DataTestUtility.TCPConnectionString;
private static readonly string s_tableName = DataTestUtility.GetShortName("VectorTestTable");
private static readonly string s_bulkCopySrcTableName = DataTestUtility.GetShortName("VectorBulkCopyTestTable");
@@ -84,9 +86,8 @@ public sealed class NativeVectorFloat32Tests : IDisposable
ORDER BY Id DESC;
END;";
- public NativeVectorFloat32Tests(ITestOutputHelper output)
+ public NativeVectorTestsBase()
{
- _output = output;
using var connection = new SqlConnection(s_connectionString);
connection.Open();
DataTestUtility.CreateTable(connection, s_tableName, s_tableDefinition);
From 5e46b47dd743157640c91584c63d0ea03611eea8 Mon Sep 17 00:00:00 2001
From: Edward Neal <55035479+edwardneal@users.noreply.github.com>
Date: Sun, 7 Jun 2026 11:45:51 +0100
Subject: [PATCH 03/26] Lift constant variables and use these consistently
---
.../SQL/VectorTest/NativeVectorTestsBase.cs | 98 ++++++++++---------
1 file changed, 50 insertions(+), 48 deletions(-)
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
index be55c939fc..a89759a80a 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
@@ -58,30 +58,32 @@ public abstract class NativeVectorTestsBase : IDisposable
where TElement : unmanaged
where TTestData : VectorTestDataBase
{
+ private const string VectorColumnName = "VectorData";
+ private const string VectorParameterName = "@VectorData";
+ private const string VectorOutputParameterName = "@OutputVectorData";
+
private static readonly string s_connectionString = ManualTesting.Tests.DataTestUtility.TCPConnectionString;
private static readonly string s_tableName = DataTestUtility.GetShortName("VectorTestTable");
private static readonly string s_bulkCopySrcTableName = DataTestUtility.GetShortName("VectorBulkCopyTestTable");
private static readonly int s_vectorDimensions = VectorFloat32TestData.vectorColumnLength;
- private static readonly string s_bulkCopySrcTableDef = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
- private static readonly string s_tableDefinition = $@"(Id INT PRIMARY KEY IDENTITY, VectorData vector({s_vectorDimensions}) NULL)";
- private static readonly string s_selectCmdString = $"SELECT VectorData FROM {s_tableName} ORDER BY Id DESC";
- private static readonly string s_insertCmdString = $"INSERT INTO {s_tableName} (VectorData) VALUES (@VectorData)";
- private static readonly string s_vectorParamName = $"@VectorData";
- private static readonly string s_outputVectorParamName = $"@OutputVectorData";
+ private static readonly string s_bulkCopySrcTableDef = $@"(Id INT PRIMARY KEY IDENTITY, {VectorColumnName} vector({s_vectorDimensions}) NULL)";
+ private static readonly string s_tableDefinition = $@"(Id INT PRIMARY KEY IDENTITY, {VectorColumnName} vector({s_vectorDimensions}) NULL)";
+ private static readonly string s_selectCmdString = $"SELECT {VectorColumnName} FROM {s_tableName} ORDER BY Id DESC";
+ private static readonly string s_insertCmdString = $"INSERT INTO {s_tableName} ({VectorColumnName}) VALUES ({VectorParameterName})";
private static readonly string s_storedProcName = DataTestUtility.GetShortName("VectorsAsVarcharSp");
private static readonly string s_storedProcBody = $@"
- {s_vectorParamName} vector({s_vectorDimensions}), -- Input: Serialized float[] as JSON string
- {s_outputVectorParamName} vector({s_vectorDimensions}) OUTPUT -- Output: Echoed back from latest inserted row
+ {VectorParameterName} vector({s_vectorDimensions}), -- Input: Serialized float[] as JSON string
+ {VectorOutputParameterName} vector({s_vectorDimensions}) OUTPUT -- Output: Echoed back from latest inserted row
AS
BEGIN
SET NOCOUNT ON;
-- Insert into vector table
- INSERT INTO {s_tableName} (VectorData)
- VALUES ({s_vectorParamName});
+ INSERT INTO {s_tableName} ({VectorColumnName})
+ VALUES ({VectorParameterName});
-- Retrieve latest entry (assumes auto-incrementing ID)
- SELECT TOP 1 {s_outputVectorParamName} = VectorData
+ SELECT TOP 1 {VectorOutputParameterName} = {VectorColumnName}
FROM {s_tableName}
ORDER BY Id DESC;
END;";
@@ -133,7 +135,7 @@ private void ValidateInsertedData(SqlConnection connection, float[] expectedData
{
ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader[0], expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(reader.IsDBNull(0), (SqlVector)reader[VectorColumnName], expectedData, expectedLength);
Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetFieldValue(0)));
@@ -142,7 +144,7 @@ private void ValidateInsertedData(SqlConnection connection, float[] expectedData
{
Assert.Equal(DBNull.Value, reader.GetValue(0));
Assert.Equal(DBNull.Value, reader[0]);
- Assert.Equal(DBNull.Value, reader["VectorData"]);
+ Assert.Equal(DBNull.Value, reader[VectorColumnName]);
Assert.Throws(() => reader.GetString(0));
Assert.Throws(() => reader.GetSqlString(0).Value);
Assert.Throws(() => reader.GetFieldValue(0));
@@ -166,14 +168,14 @@ public void TestSqlVectorFloat32ParameterInsertionAndReads(
{
1 => new SqlParameter
{
- ParameterName = s_vectorParamName,
+ ParameterName = VectorParameterName,
SqlDbType = SqlDbTypeExtensions.Vector,
Value = value
},
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
+ 2 => new SqlParameter(VectorParameterName, value),
+ 3 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector) { Value = value },
// Even if size is specified, the actual size is determined by the value passed and specified size is ignored.
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ 4 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
_ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
};
@@ -199,7 +201,7 @@ private async Task ValidateInsertedDataAsync(SqlConnection connection, float[] e
{
ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader.GetValue(0), expectedData, expectedLength);
ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader[0], expectedData, expectedLength);
- ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader["VectorData"], expectedData, expectedLength);
+ ValidateSqlVectorFloat32Object(await reader.IsDBNullAsync(0), (SqlVector)reader[VectorColumnName], expectedData, expectedLength);
Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetString(0)));
Assert.Equal(expectedData, JsonSerializer.Deserialize(reader.GetSqlString(0).Value));
Assert.Equal(expectedData, JsonSerializer.Deserialize(await reader.GetFieldValueAsync(0)));
@@ -208,7 +210,7 @@ private async Task ValidateInsertedDataAsync(SqlConnection connection, float[] e
{
Assert.Equal(DBNull.Value, reader.GetValue(0));
Assert.Equal(DBNull.Value, reader[0]);
- Assert.Equal(DBNull.Value, reader["VectorData"]);
+ Assert.Equal(DBNull.Value, reader[VectorColumnName]);
Assert.Throws(() => reader.GetString(0));
Assert.Throws(() => reader.GetSqlString(0).Value);
await Assert.ThrowsAsync(async () => await reader.GetFieldValueAsync(0));
@@ -232,13 +234,13 @@ public async Task TestSqlVectorFloat32ParameterInsertionAndReadsAsync(
{
1 => new SqlParameter
{
- ParameterName = s_vectorParamName,
+ ParameterName = VectorParameterName,
SqlDbType = (SqlDbType)36, // SqlDbTypeExtension.Vector
Value = value
},
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ 2 => new SqlParameter(VectorParameterName, value),
+ 3 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
_ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
};
@@ -271,20 +273,20 @@ public void TestStoredProcParamsForVectorFloat32(
{
1 => new SqlParameter
{
- ParameterName = s_vectorParamName,
+ ParameterName = VectorParameterName,
SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
Value = value
},
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ 2 => new SqlParameter(VectorParameterName, value),
+ 3 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
_ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
};
command.Parameters.Add(inputParam);
var outputParam = new SqlParameter
{
- ParameterName = s_outputVectorParamName,
+ ParameterName = VectorOutputParameterName,
SqlDbType = SqlDbTypeExtensions.Vector,
Direction = ParameterDirection.Output,
Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
@@ -301,7 +303,7 @@ public void TestStoredProcParamsForVectorFloat32(
// Validate error for conventional way of setting output parameters
command.Parameters.Clear();
command.Parameters.Add(inputParam);
- var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
+ var outputParamWithoutVal = new SqlParameter(VectorOutputParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
command.Parameters.Add(outputParamWithoutVal);
Assert.Throws(() => command.ExecuteNonQuery());
}
@@ -328,20 +330,20 @@ public async Task TestStoredProcParamsForVectorFloat32Async(
{
1 => new SqlParameter
{
- ParameterName = s_vectorParamName,
+ ParameterName = VectorParameterName,
SqlDbType = SqlDbTypeExtensions.Vector, // SqlDbTypeExtension.Vector
Value = value
},
- 2 => new SqlParameter(s_vectorParamName, value),
- 3 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector) { Value = value },
- 4 => new SqlParameter(s_vectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
+ 2 => new SqlParameter(VectorParameterName, value),
+ 3 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector) { Value = value },
+ 4 => new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Value = value },
_ => throw new ArgumentOutOfRangeException(nameof(pattern), $"Unsupported pattern: {pattern}")
};
command.Parameters.Add(inputParam);
var outputParam = new SqlParameter
{
- ParameterName = s_outputVectorParamName,
+ ParameterName = VectorOutputParameterName,
SqlDbType = SqlDbTypeExtensions.Vector,
Direction = ParameterDirection.Output,
Value = SqlVector.CreateNull(VectorFloat32TestData.vectorColumnLength)
@@ -358,7 +360,7 @@ public async Task TestStoredProcParamsForVectorFloat32Async(
// Validate error for conventional way of setting output parameters
command.Parameters.Clear();
command.Parameters.Add(inputParam);
- var outputParamWithoutVal = new SqlParameter(s_outputVectorParamName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
+ var outputParamWithoutVal = new SqlParameter(VectorOutputParameterName, SqlDbTypeExtensions.Vector, VectorFloat32TestData.IncorrectParamSize) { Direction = ParameterDirection.Output };
command.Parameters.Add(outputParamWithoutVal);
await Assert.ThrowsAsync(async () => await command.ExecuteNonQueryAsync());
}
@@ -379,8 +381,8 @@ public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
case 1:
// Use SqlServer table as source
- var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
- var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
+ var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values ({VectorParameterName})", sourceConnection);
+ var vectorParam = new SqlParameter(VectorParameterName, new SqlVector(VectorFloat32TestData.testData));
// Insert 2 rows with one non-null and null value
insertCmd.Parameters.Add(vectorParam);
@@ -394,7 +396,7 @@ public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
case 2:
table = new DataTable(s_bulkCopySrcTableName);
table.Columns.Add("Id", typeof(int));
- table.Columns.Add("VectorData", typeof(SqlVector));
+ table.Columns.Add(VectorColumnName, typeof(SqlVector));
table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
table.Rows.Add(2, DBNull.Value);
break;
@@ -405,7 +407,7 @@ public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
//Bulkcopy from sql server table to destination table
- using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
+ using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, {VectorColumnName} FROM {s_bulkCopySrcTableName}", sourceConnection);
using SqlDataReader reader = sourceDataCommand.ExecuteReader();
// Verify that the destination table is empty before bulk copy
@@ -442,7 +444,7 @@ public void TestBulkCopyFromSqlTable(int bulkCopySourceMode)
Assert.Equal(2, Convert.ToInt16(countCommand.ExecuteScalar()));
// Read the data from destination table as varbinary to verify the UTF-8 byte sequence
- using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
+ using SqlCommand verifyCommand = new SqlCommand($"SELECT {VectorColumnName} from {s_tableName}", destinationConnection);
using SqlDataReader verifyReader = verifyCommand.ExecuteReader();
// Verify that we have data in the destination table
@@ -479,8 +481,8 @@ public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
case 1:
// Use SqlServer table as source
- var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values (@VectorData)", sourceConnection);
- var vectorParam = new SqlParameter(s_vectorParamName, new SqlVector(VectorFloat32TestData.testData));
+ var insertCmd = new SqlCommand($"insert into {s_bulkCopySrcTableName} values ({VectorParameterName})", sourceConnection);
+ var vectorParam = new SqlParameter(VectorParameterName, new SqlVector(VectorFloat32TestData.testData));
// Insert 2 rows with one non-null and null value
insertCmd.Parameters.Add(vectorParam);
@@ -494,7 +496,7 @@ public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
case 2:
table = new DataTable(s_bulkCopySrcTableName);
table.Columns.Add("Id", typeof(int));
- table.Columns.Add("VectorData", typeof(SqlVector));
+ table.Columns.Add(VectorColumnName, typeof(SqlVector));
table.Rows.Add(1, new SqlVector(VectorFloat32TestData.testData));
table.Rows.Add(2, DBNull.Value);
break;
@@ -503,7 +505,7 @@ public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
}
//Bulkcopy from sql server table to destination table
- using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, VectorData FROM {s_bulkCopySrcTableName}", sourceConnection);
+ using SqlCommand sourceDataCommand = new SqlCommand($"SELECT Id, {VectorColumnName} FROM {s_bulkCopySrcTableName}", sourceConnection);
using SqlDataReader reader = await sourceDataCommand.ExecuteReaderAsync();
// Verify that the destination table is empty before bulk copy
@@ -540,7 +542,7 @@ public async Task TestBulkCopyFromSqlTableAsync(int bulkCopySourceMode)
Assert.Equal(2, Convert.ToInt16(await countCommand.ExecuteScalarAsync()));
// Read the data from destination table as varbinary to verify the UTF-8 byte sequence
- using SqlCommand verifyCommand = new SqlCommand($"SELECT VectorData from {s_tableName}", destinationConnection);
+ using SqlCommand verifyCommand = new SqlCommand($"SELECT {VectorColumnName} from {s_tableName}", destinationConnection);
using SqlDataReader verifyReader = await verifyCommand.ExecuteReaderAsync();
// Verify that we have data in the destination table
@@ -571,7 +573,7 @@ public void TestGetFieldTypeReturnsSqlVectorForVectorColumn()
// Insert a row so we can query it
using (var insertCmd = new SqlCommand(s_insertCmdString, connection))
{
- var param = insertCmd.Parameters.Add(s_vectorParamName, SqlDbTypeExtensions.Vector);
+ var param = insertCmd.Parameters.Add(VectorParameterName, SqlDbTypeExtensions.Vector);
param.Value = new SqlVector(VectorFloat32TestData.testData);
insertCmd.ExecuteNonQuery();
}
@@ -603,7 +605,7 @@ public void TestInsertVectorsFloat32WithPrepare()
SqlConnection conn = new SqlConnection(s_connectionString);
conn.Open();
SqlCommand command = new SqlCommand(s_insertCmdString, conn);
- SqlParameter vectorParam = new SqlParameter("@VectorData", SqlDbTypeExtensions.Vector);
+ SqlParameter vectorParam = new SqlParameter(VectorParameterName, SqlDbTypeExtensions.Vector);
command.Parameters.Add(vectorParam);
command.Prepare();
for (int i = 0; i < 10; i++)
@@ -611,7 +613,7 @@ public void TestInsertVectorsFloat32WithPrepare()
vectorParam.Value = new SqlVector(new float[] { i + 0.1f, i + 0.2f, i + 0.3f, i + 0.4f, i + 0.5f, i + 0.6f });
command.ExecuteNonQuery();
}
- SqlCommand validateCommand = new SqlCommand($"SELECT VectorData FROM {s_tableName}", conn);
+ SqlCommand validateCommand = new SqlCommand($"SELECT {VectorColumnName} FROM {s_tableName}", conn);
using SqlDataReader reader = validateCommand.ExecuteReader();
int rowcnt = 0;
while (reader.Read())
From 0a33c47140adcd2403a86f181533fb2370e4540a Mon Sep 17 00:00:00 2001
From: Edward Neal <55035479+edwardneal@users.noreply.github.com>
Date: Sun, 7 Jun 2026 11:56:31 +0100
Subject: [PATCH 04/26] Use generics for vector supported flag and test data
---
.../VectorTest/NativeVectorFloat32Tests.cs | 5 ++-
.../SQL/VectorTest/NativeVectorTestsBase.cs | 44 +++++++++++++------
2 files changed, 34 insertions(+), 15 deletions(-)
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
index ce5ff05732..68438c9d39 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorFloat32Tests.cs
@@ -2,12 +2,15 @@
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+using System.Collections.Generic;
+
namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest;
#nullable enable
-public sealed class VectorFloat32TestData : VectorTestDataBase
+public sealed class VectorFloat32TestData : NativeVectorTestDataBase
{
+ public override bool IsSupported => DataTestUtility.IsSqlVectorSupported;
}
public sealed class NativeVectorFloat32Tests : NativeVectorTestsBase
diff --git a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
index a89759a80a..447ee04f03 100644
--- a/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
+++ b/src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/VectorTest/NativeVectorTestsBase.cs
@@ -14,7 +14,7 @@
namespace Microsoft.Data.SqlClient.ManualTesting.Tests.SQL.VectorTest
{
- public abstract class VectorTestDataBase
+ public abstract class NativeVectorTestDataBase
where TElement : unmanaged
{
public const int VectorHeaderSize = 8;
@@ -22,6 +22,11 @@ public abstract class VectorTestDataBase
public static int vectorColumnLength = testData.Length;
// Incorrect size for SqlParameter.Size
public static int IncorrectParamSize = 3234;
+
+ public abstract bool IsSupported { get; }
+
+ public IEnumerable TestData => GetVectorFloat32TestData();
+
public static IEnumerable GetVectorFloat32TestData()
{
// Pattern 1-4 with SqlVector(values: testData)
@@ -56,7 +61,7 @@ public static IEnumerable