Add MoneyConverter and VectorConverter support

- Added MoneyConverter with NumberStyles.Currency for SQL Server money/smallmoney types
  - Supports currency symbols ($, €, £, etc.)
  - Supports thousands separators (1,234.56)
  - Supports negative parentheses accounting format ((0.00))
  - Supports scientific notation

- Added VectorConverter for SQL Server 2025 VECTOR data type
  - Supports JSON array format: [0.1, 0.2, 0.3]
  - Supports comma-separated format: 0.1, 0.2, 0.3
  - Supports scientific notation in vector elements
  - Handles large embeddings (tested with 100+ dimensions)

- Added comprehensive test coverage for both converters
  - MoneyConverter: currency symbols, thousands separators, scientific notation
  - VectorConverter: JSON arrays, comma-separated, scientific notation, edge cases

Co-authored-by: Chrissy LeMaire <[email protected]>

Author: github-actions[bot]

project/dbatools.Tests/Csv/TypeConverterTest.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Dataplat.Dbatools.Csv.TypeConverters;
 
@@ -181,6 +182,184 @@ public void TestDecimalConverterScientificNotation()
             Assert.AreEqual(-314m, result);
         }
 
+        [TestMethod]
+        public void TestMoneyConverter()
+        {
+            var converter = MoneyConverter.Default;
+
+            // Test basic decimal values
+            Assert.IsTrue(converter.TryConvert("123.45", out decimal result));
+            Assert.AreEqual(123.45m, result);
+
+            // Test negative values
+            Assert.IsTrue(converter.TryConvert("-99.99", out result));
+            Assert.AreEqual(-99.99m, result);
+        }
+
+        [TestMethod]
+        public void TestMoneyConverterWithCurrencySymbols()
+        {
+            var converter = MoneyConverter.Default;
+
+            // Test US dollar sign
+            Assert.IsTrue(converter.TryConvert("$123.45", out decimal result));
+            Assert.AreEqual(123.45m, result);
+
+            // Test negative with dollar sign
+            Assert.IsTrue(converter.TryConvert("-$99.99", out result));
+            Assert.AreEqual(-99.99m, result);
+
+            // Test parentheses for negative (accounting format)
+            Assert.IsTrue(converter.TryConvert("($50.00)", out result));
+            Assert.AreEqual(-50.00m, result);
+        }
+
+        [TestMethod]
+        public void TestMoneyConverterWithThousandsSeparator()
+        {
+            var converter = MoneyConverter.Default;
+
+            // Test with thousands separator
+            Assert.IsTrue(converter.TryConvert("$1,234.56", out decimal result));
+            Assert.AreEqual(1234.56m, result);
+
+            // Test large number with currency
+            Assert.IsTrue(converter.TryConvert("$1,234,567.89", out result));
+            Assert.AreEqual(1234567.89m, result);
+        }
+
+        [TestMethod]
+        public void TestMoneyConverterScientificNotation()
+        {
+            var converter = MoneyConverter.Default;
+
+            // NumberStyles.Currency includes AllowExponent, so scientific notation should work
+            Assert.IsTrue(converter.TryConvert("1.5E3", out decimal result));
+            Assert.AreEqual(1500m, result);
+
+            Assert.IsTrue(converter.TryConvert("2.5E-2", out result));
+            Assert.AreEqual(0.025m, result);
+        }
+
+        [TestMethod]
+        public void TestMoneyConverterInvalidInput()
+        {
+            var converter = MoneyConverter.Default;
+
+            Assert.IsFalse(converter.TryConvert("invalid", out _));
+            Assert.IsFalse(converter.TryConvert("", out _));
+            Assert.IsFalse(converter.TryConvert(null, out _));
+        }
+
+        #endregion
+
+        #region Vector Converter Tests
+
+        [TestMethod]
+        public void TestVectorConverterJsonArrayFormat()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test JSON array format
+            Assert.IsTrue(converter.TryConvert("[0.1, 0.2, 0.3]", out float[] result));
+            Assert.AreEqual(3, result.Length);
+            Assert.AreEqual(0.1f, result[0], 0.0001f);
+            Assert.AreEqual(0.2f, result[1], 0.0001f);
+            Assert.AreEqual(0.3f, result[2], 0.0001f);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterCommaSeparated()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test comma-separated format (no brackets)
+            Assert.IsTrue(converter.TryConvert("0.5, 1.0, 1.5", out float[] result));
+            Assert.AreEqual(3, result.Length);
+            Assert.AreEqual(0.5f, result[0], 0.0001f);
+            Assert.AreEqual(1.0f, result[1], 0.0001f);
+            Assert.AreEqual(1.5f, result[2], 0.0001f);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterScientificNotation()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test scientific notation in vectors
+            Assert.IsTrue(converter.TryConvert("[1.5e-3, 2.0E2, -3.5e1]", out float[] result));
+            Assert.AreEqual(3, result.Length);
+            Assert.AreEqual(0.0015f, result[0], 0.000001f);
+            Assert.AreEqual(200.0f, result[1], 0.0001f);
+            Assert.AreEqual(-35.0f, result[2], 0.0001f);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterNegativeValues()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test negative values
+            Assert.IsTrue(converter.TryConvert("[-0.5, -1.0, -1.5]", out float[] result));
+            Assert.AreEqual(3, result.Length);
+            Assert.AreEqual(-0.5f, result[0], 0.0001f);
+            Assert.AreEqual(-1.0f, result[1], 0.0001f);
+            Assert.AreEqual(-1.5f, result[2], 0.0001f);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterLargeEmbedding()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test realistic embedding size (e.g., OpenAI ada-002 uses 1536 dimensions)
+            // Create a sample with 100 dimensions for testing
+            string vectorString = "[" + string.Join(", ", Enumerable.Range(0, 100).Select(i => (i * 0.01f).ToString("F3"))) + "]";
+
+            Assert.IsTrue(converter.TryConvert(vectorString, out float[] result));
+            Assert.AreEqual(100, result.Length);
+            Assert.AreEqual(0.0f, result[0], 0.0001f);
+            Assert.AreEqual(0.99f, result[99], 0.0001f);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterWhitespaceHandling()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test various whitespace scenarios
+            Assert.IsTrue(converter.TryConvert("  [  0.1  ,  0.2  ,  0.3  ]  ", out float[] result));
+            Assert.AreEqual(3, result.Length);
+
+            Assert.IsTrue(converter.TryConvert("0.1,0.2,0.3", out result)); // No spaces
+            Assert.AreEqual(3, result.Length);
+        }
+
+        [TestMethod]
+        public void TestVectorConverterInvalidInput()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test invalid inputs
+            Assert.IsFalse(converter.TryConvert("", out _));
+            Assert.IsFalse(converter.TryConvert(null, out _));
+            Assert.IsFalse(converter.TryConvert("[]", out _)); // Empty array
+            Assert.IsFalse(converter.TryConvert("[not, a, number]", out _));
+            Assert.IsFalse(converter.TryConvert("[0.1, invalid, 0.3]", out _));
+            Assert.IsFalse(converter.TryConvert("[", out _)); // Malformed
+        }
+
+        [TestMethod]
+        public void TestVectorConverterSingleValue()
+        {
+            var converter = VectorConverter.Default;
+
+            // Test single-value vector
+            Assert.IsTrue(converter.TryConvert("[42.5]", out float[] result));
+            Assert.AreEqual(1, result.Length);
+            Assert.AreEqual(42.5f, result[0], 0.0001f);
+        }
+
         #endregion
 
         #region Type Converter Registry Tests

project/dbatools/Csv/TypeConverters/NumericConverters.cs

@@ -183,6 +183,33 @@ protected override bool TryParseCore(string value, NumberStyles styles, IFormatP
         /// <inheritdoc />
         protected override bool TryParseSpan(ReadOnlySpan<char> value, NumberStyles styles, IFormatProvider provider, out byte result)
             => byte.TryParse(value, styles, provider, out result);
+#endif
+    }
+
+    /// <summary>
+    /// Converts string values to Decimal values with currency symbol support.
+    /// Supports culture-aware parsing for currency symbols, decimal separators, and scientific notation.
+    /// Suitable for SQL Server money and smallmoney data types.
+    /// </summary>
+    public sealed class MoneyConverter : CultureAwareConverterBase<decimal>
+    {
+        /// <summary>Gets the default instance of the converter.</summary>
+        public static MoneyConverter Default { get; } = new MoneyConverter();
+
+        /// <summary>Initializes a new instance of the <see cref="MoneyConverter"/> class.</summary>
+        public MoneyConverter()
+        {
+            NumberStyles = NumberStyles.Currency;
+        }
+
+        /// <inheritdoc />
+        protected override bool TryParseCore(string value, NumberStyles styles, IFormatProvider provider, out decimal result)
+            => decimal.TryParse(value, styles, provider, out result);
+
+#if NET8_0_OR_GREATER
+        /// <inheritdoc />
+        protected override bool TryParseSpan(ReadOnlySpan<char> value, NumberStyles styles, IFormatProvider provider, out decimal result)
+            => decimal.TryParse(value, styles, provider, out result);
 #endif
     }
 }

project/dbatools/Csv/TypeConverters/VectorConverter.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Globalization;
+using System.Linq;
+
+namespace Dataplat.Dbatools.Csv.TypeConverters
+{
+    /// <summary>
+    /// Converts string values to float arrays for SQL Server 2025 VECTOR data type.
+    /// Supports JSON array format: "[0.1, 0.2, 0.3, ...]"
+    /// Supports comma-separated format: "0.1, 0.2, 0.3, ..."
+    /// </summary>
+    public sealed class VectorConverter : TypeConverterBase<float[]>
+    {
+        /// <summary>Gets the default instance of the converter.</summary>
+        public static VectorConverter Default { get; } = new VectorConverter();
+
+        /// <summary>
+        /// Gets or sets the format provider to use for parsing individual float values.
+        /// Defaults to InvariantCulture.
+        /// </summary>
+        public IFormatProvider FormatProvider { get; set; } = CultureInfo.InvariantCulture;
+
+        /// <summary>
+        /// Attempts to convert the string value to a float array.
+        /// Supports both JSON array format "[0.1, 0.2]" and comma-separated format "0.1, 0.2"
+        /// </summary>
+        public override bool TryConvert(string value, out float[] result)
+        {
+            result = null;
+
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return false;
+            }
+
+            // Trim whitespace
+            value = value.Trim();
+
+            // Check for JSON array format and strip brackets
+            if (value.StartsWith("[") && value.EndsWith("]"))
+            {
+                value = value.Substring(1, value.Length - 2);
+            }
+
+            // Split by comma and parse each value
+            string[] parts = value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+
+            if (parts.Length == 0)
+            {
+                return false;
+            }
+
+            float[] vector = new float[parts.Length];
+
+            for (int i = 0; i < parts.Length; i++)
+            {
+                string part = parts[i].Trim();
+
+                // Try parsing with Float styles to support scientific notation
+                if (!float.TryParse(part, NumberStyles.Float | NumberStyles.AllowThousands, FormatProvider, out vector[i]))
+                {
+                    return false;
+                }
+            }
+
+            result = vector;
+            return true;
+        }
+    }
+}