diff --git a/src/fb-cpp/Statement.h b/src/fb-cpp/Statement.h
index 09d2f93..8c880fc 100644
--- a/src/fb-cpp/Statement.h
+++ b/src/fb-cpp/Statement.h
@@ -37,6 +37,7 @@
 #include "SmartPtrs.h"
 #include "Exception.h"
 #include "StructBinding.h"
+#include "VariantTypeTraits.h"
 #include <charconv>
 #include <cerrno>
 #include <cstdlib>
@@ -1565,7 +1566,7 @@ namespace fbcpp
 		}
 
 		///
-		/// @brief Reads a Firebird 128-bit integer column.
+		/// @brief Reads a Firebird scaled 128-bit integer column.
 		///
 		std::optional<ScaledOpaqueInt128> getScaledOpaqueInt128(unsigned index)
 		{
@@ -1585,7 +1586,7 @@ namespace fbcpp
 						descriptor.scale};
 
 				default:
-					throwInvalidType("OpaqueInt128", descriptor.adjustedType);
+					throwInvalidType("ScaledOpaqueInt128", descriptor.adjustedType);
 			}
 		}
 
@@ -2130,6 +2131,72 @@ namespace fbcpp
 			setTuple(value, std::make_index_sequence<N>{});
 		}
 
+		///
+		/// @brief Retrieves a column value as a user-defined variant type.
+		/// @tparam V A std::variant type with possible C++ types. Use std::monostate for NULL.
+		/// @param index Zero-based column index.
+		/// @return The variant with column value, or std::monostate if NULL.
+		/// @throws FbCppException if NULL but variant lacks std::monostate.
+		/// @throws FbCppException if SQL type cannot convert to any alternative.
+		///
+		template <VariantLike V>
+		V get(unsigned index)
+		{
+			using namespace impl::reflection;
+
+			static_assert(variantAlternativesSupportedV<V>,
+				"Variant contains unsupported types. All variant alternatives must be types supported by fb-cpp "
+				"(e.g., std::int32_t, std::string, Date, ScaledOpaqueInt128, etc.). Check VariantTypeTraits.h for the "
+				"complete list of supported types.");
+
+			assert(isValid());
+
+			const auto& descriptor = getOutDescriptor(index);
+
+			if (isNull(index))
+			{
+				if constexpr (variantContainsV<std::monostate, V>)
+					return V{std::monostate{}};
+				else
+				{
+					throw FbCppException(
+						"NULL value encountered but variant does not contain std::monostate at index " +
+						std::to_string(index));
+				}
+			}
+
+			return getVariantValue<V>(index, descriptor);
+		}
+
+		///
+		/// @brief Sets a parameter from a variant value.
+		/// @tparam V A std::variant type.
+		/// @param index Zero-based parameter index.
+		/// @param value The variant containing the value.
+		///
+		template <VariantLike V>
+		void set(unsigned index, const V& value)
+		{
+			using namespace impl::reflection;
+
+			static_assert(variantAlternativesSupportedV<V>,
+				"Variant contains unsupported types. All variant alternatives must be types supported by fb-cpp "
+				"(e.g., std::int32_t, std::string, Date, ScaledOpaqueInt128, etc.). Check VariantTypeTraits.h for the "
+				"complete list of supported types.");
+
+			std::visit(
+				[this, index](const auto& v)
+				{
+					using T = std::decay_t<decltype(v)>;
+
+					if constexpr (std::is_same_v<T, std::monostate>)
+						setNull(index);
+					else
+						set(index, v);
+				},
+				value);
+		}
+
 	private:
 		///
 		/// @brief Validates and returns the descriptor for the given input parameter index.
@@ -2174,6 +2241,8 @@ namespace fbcpp
 
 			if constexpr (isOptionalV<F>)
 				return get<F>(index);
+			else if constexpr (isVariantV<F>)
+				return get<F>(index);
 			else
 			{
 				auto opt = get<std::optional<F>>(index);
@@ -2220,6 +2289,211 @@ namespace fbcpp
 			(set(static_cast<unsigned>(Is), std::get<Is>(value)), ...);
 		}
 
+		///
+		/// @brief Helper to retrieve a column value as a variant.
+		/// Uses priority: exact type match first, then declaration order for conversions.
+		///
+		template <typename V>
+		V getVariantValue(unsigned index, const Descriptor& descriptor)
+		{
+			using namespace impl::reflection;
+
+			// Try exact type matches first based on SQL type
+			switch (descriptor.adjustedType)
+			{
+				case DescriptorAdjustedType::BOOLEAN:
+					if constexpr (variantContainsV<bool, V>)
+						return V{get<std::optional<bool>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::INT16:
+					if (descriptor.scale != 0)
+					{
+						// For scaled numbers, prefer exact scaled type, then larger scaled types
+						if constexpr (variantContainsV<ScaledInt16, V>)
+							return V{get<std::optional<ScaledInt16>>(index).value()};
+						if constexpr (variantContainsV<ScaledInt32, V>)
+							return V{get<std::optional<ScaledInt32>>(index).value()};
+						if constexpr (variantContainsV<ScaledInt64, V>)
+							return V{get<std::optional<ScaledInt64>>(index).value()};
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+						if constexpr (variantContainsV<ScaledBoostInt128, V>)
+							return V{get<std::optional<ScaledBoostInt128>>(index).value()};
+#endif
+					}
+					if constexpr (variantContainsV<std::int16_t, V>)
+						return V{get<std::optional<std::int16_t>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::INT32:
+					if (descriptor.scale != 0)
+					{
+						// For scaled numbers, prefer exact scaled type, then larger scaled types
+						if constexpr (variantContainsV<ScaledInt32, V>)
+							return V{get<std::optional<ScaledInt32>>(index).value()};
+						if constexpr (variantContainsV<ScaledInt64, V>)
+							return V{get<std::optional<ScaledInt64>>(index).value()};
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+						if constexpr (variantContainsV<ScaledBoostInt128, V>)
+							return V{get<std::optional<ScaledBoostInt128>>(index).value()};
+#endif
+					}
+					if constexpr (variantContainsV<std::int32_t, V>)
+						return V{get<std::optional<std::int32_t>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::INT64:
+					if (descriptor.scale != 0)
+					{
+						// For scaled numbers, prefer exact scaled type, then larger scaled types
+						if constexpr (variantContainsV<ScaledInt64, V>)
+							return V{get<std::optional<ScaledInt64>>(index).value()};
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+						if constexpr (variantContainsV<ScaledBoostInt128, V>)
+							return V{get<std::optional<ScaledBoostInt128>>(index).value()};
+#endif
+					}
+					if constexpr (variantContainsV<std::int64_t, V>)
+						return V{get<std::optional<std::int64_t>>(index).value()};
+					break;
+
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+				case DescriptorAdjustedType::INT128:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<ScaledOpaqueInt128, V>)
+						return V{get<std::optional<ScaledOpaqueInt128>>(index).value()};
+					if (descriptor.scale != 0)
+					{
+						if constexpr (variantContainsV<ScaledBoostInt128, V>)
+							return V{get<std::optional<ScaledBoostInt128>>(index).value()};
+					}
+					if constexpr (variantContainsV<BoostInt128, V>)
+						return V{get<std::optional<BoostInt128>>(index).value()};
+					break;
+#endif
+
+				case DescriptorAdjustedType::FLOAT:
+					if constexpr (variantContainsV<float, V>)
+						return V{get<std::optional<float>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::DOUBLE:
+					if constexpr (variantContainsV<double, V>)
+						return V{get<std::optional<double>>(index).value()};
+					break;
+
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+				case DescriptorAdjustedType::DECFLOAT16:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueDecFloat16, V>)
+						return V{get<std::optional<OpaqueDecFloat16>>(index).value()};
+					if constexpr (variantContainsV<BoostDecFloat16, V>)
+						return V{get<std::optional<BoostDecFloat16>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::DECFLOAT34:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueDecFloat34, V>)
+						return V{get<std::optional<OpaqueDecFloat34>>(index).value()};
+					if constexpr (variantContainsV<BoostDecFloat34, V>)
+						return V{get<std::optional<BoostDecFloat34>>(index).value()};
+					break;
+#endif
+
+				case DescriptorAdjustedType::STRING:
+					if constexpr (variantContainsV<std::string, V>)
+						return V{get<std::optional<std::string>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::DATE:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueDate, V>)
+						return V{get<std::optional<OpaqueDate>>(index).value()};
+					if constexpr (variantContainsV<Date, V>)
+						return V{get<std::optional<Date>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::TIME:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueTime, V>)
+						return V{get<std::optional<OpaqueTime>>(index).value()};
+					if constexpr (variantContainsV<Time, V>)
+						return V{get<std::optional<Time>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::TIMESTAMP:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueTimestamp, V>)
+						return V{get<std::optional<OpaqueTimestamp>>(index).value()};
+					if constexpr (variantContainsV<Timestamp, V>)
+						return V{get<std::optional<Timestamp>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::TIME_TZ:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueTimeTz, V>)
+						return V{get<std::optional<OpaqueTimeTz>>(index).value()};
+					if constexpr (variantContainsV<TimeTz, V>)
+						return V{get<std::optional<TimeTz>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::TIMESTAMP_TZ:
+					// Prefer opaque (native Firebird) types first
+					if constexpr (variantContainsV<OpaqueTimestampTz, V>)
+						return V{get<std::optional<OpaqueTimestampTz>>(index).value()};
+					if constexpr (variantContainsV<TimestampTz, V>)
+						return V{get<std::optional<TimestampTz>>(index).value()};
+					break;
+
+				case DescriptorAdjustedType::BLOB:
+					if constexpr (variantContainsV<BlobId, V>)
+						return V{get<std::optional<BlobId>>(index).value()};
+					break;
+
+				default:
+					break;
+			}
+
+			// No exact match found, try variant alternatives in declaration order
+			return tryVariantAlternatives<V, 0>(index, descriptor);
+		}
+
+		///
+		/// @brief Recursively tries variant alternatives for type conversion.
+		///
+		template <typename V, std::size_t I = 0>
+		V tryVariantAlternatives(unsigned index, [[maybe_unused]] const Descriptor& descriptor)
+		{
+			using namespace impl::reflection;
+
+			if constexpr (I >= std::variant_size_v<V>)
+			{
+				throw FbCppException(
+					"Cannot convert SQL type to any variant alternative at index " + std::to_string(index));
+			}
+			else
+			{
+				using Alt = std::variant_alternative_t<I, V>;
+
+				if constexpr (std::is_same_v<Alt, std::monostate>)
+				{
+					// Skip monostate in non-null case
+					return tryVariantAlternatives<V, I + 1>(index, descriptor);
+				}
+				else if constexpr (isOpaqueTypeV<Alt>)
+				{
+					// Skip opaque types - they only match exact SQL types, no conversions
+					return tryVariantAlternatives<V, I + 1>(index, descriptor);
+				}
+				else
+				{
+					// Try this alternative - get<T> will throw if conversion fails
+					auto opt = get<std::optional<Alt>>(index);
+					return V{std::move(opt.value())};
+				}
+			}
+		}
+
 		///
 		/// @brief Converts and writes numeric parameter values following descriptor rules.
 		///
diff --git a/src/fb-cpp/StructBinding.h b/src/fb-cpp/StructBinding.h
index a8c5af8..9b12478 100644
--- a/src/fb-cpp/StructBinding.h
+++ b/src/fb-cpp/StructBinding.h
@@ -30,6 +30,7 @@
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <variant>
 
 
 namespace fbcpp
@@ -66,6 +67,50 @@ namespace fbcpp::impl::reflection
 	template <typename T>
 	inline constexpr bool isOptionalV = IsOptional<T>::value;
 
+	///
+	/// Helper to detect std::variant.
+	///
+	template <typename T>
+	struct IsVariant : std::false_type
+	{
+	};
+
+	template <typename... Ts>
+	struct IsVariant<std::variant<Ts...>> : std::true_type
+	{
+	};
+
+	template <typename T>
+	inline constexpr bool isVariantV = IsVariant<T>::value;
+
+	///
+	/// Check if variant contains a specific type.
+	///
+	template <typename T, typename Variant>
+	struct VariantContains : std::false_type
+	{
+	};
+
+	template <typename T, typename... Ts>
+	struct VariantContains<T, std::variant<Ts...>> : std::disjunction<std::is_same<T, Ts>...>
+	{
+	};
+
+	template <typename T, typename Variant>
+	inline constexpr bool variantContainsV = VariantContains<T, Variant>::value;
+
+	///
+	/// Helper to detect opaque (non-convertible) types that only match exact SQL types.
+	/// Forward declarations for opaque types from types.h.
+	///
+	template <typename T>
+	struct IsOpaqueType : std::false_type
+	{
+	};
+
+	template <typename T>
+	inline constexpr bool isOpaqueTypeV = IsOpaqueType<T>::value;
+
 	/// Universal converter for aggregate initialization detection.
 	struct UniversalType
 	{
@@ -334,5 +379,14 @@ namespace fbcpp::impl::reflection
 	using FieldType = std::remove_reference_t<std::tuple_element_t<I, TupleType<T>>>;
 }  // namespace fbcpp::impl::reflection
 
+namespace fbcpp
+{
+	///
+	/// Concept constraining types to std::variant types.
+	///
+	template <typename T>
+	concept VariantLike = impl::reflection::isVariantV<std::remove_cvref_t<T>>;
+}  // namespace fbcpp
+
 
 #endif  // FBCPP_STRUCT_BINDING_H
diff --git a/src/fb-cpp/VariantTypeTraits.h b/src/fb-cpp/VariantTypeTraits.h
new file mode 100644
index 0000000..57bdbf1
--- /dev/null
+++ b/src/fb-cpp/VariantTypeTraits.h
@@ -0,0 +1,253 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2025 Adriano dos Santos Fernandes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef FBCPP_VARIANT_TYPE_TRAITS_H
+#define FBCPP_VARIANT_TYPE_TRAITS_H
+
+#include "config.h"
+#include "types.h"
+#include "StructBinding.h"
+
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#endif
+
+
+namespace fbcpp::impl::reflection
+{
+	///
+	/// Helper to check if a type is supported by the library for variant usage.
+	///
+	template <typename T>
+	struct IsSupportedVariantType : std::false_type
+	{
+	};
+
+	// Arithmetic types
+	template <>
+	struct IsSupportedVariantType<bool> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<std::int16_t> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<std::int32_t> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<std::int64_t> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<float> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<double> : std::true_type
+	{
+	};
+
+	// Scaled numbers
+	template <>
+	struct IsSupportedVariantType<ScaledInt16> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<ScaledInt32> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<ScaledInt64> : std::true_type
+	{
+	};
+
+	// String
+	template <>
+	struct IsSupportedVariantType<std::string> : std::true_type
+	{
+	};
+
+	// Date/Time types
+	template <>
+	struct IsSupportedVariantType<Date> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<Time> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<Timestamp> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<TimeTz> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<TimestampTz> : std::true_type
+	{
+	};
+
+	// Opaque Date/Time types
+	template <>
+	struct IsSupportedVariantType<OpaqueDate> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueTime> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueTimestamp> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueTimeTz> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueTimestampTz> : std::true_type
+	{
+	};
+
+	// Blob
+	template <>
+	struct IsSupportedVariantType<BlobId> : std::true_type
+	{
+	};
+
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+	// Boost multiprecision types
+	template <>
+	struct IsSupportedVariantType<BoostInt128> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<ScaledBoostInt128> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<BoostDecFloat16> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<BoostDecFloat34> : std::true_type
+	{
+	};
+
+	// Opaque multiprecision types
+	template <>
+	struct IsSupportedVariantType<ScaledOpaqueInt128> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueDecFloat16> : std::true_type
+	{
+	};
+	template <>
+	struct IsSupportedVariantType<OpaqueDecFloat34> : std::true_type
+	{
+	};
+#endif
+
+	// std::monostate is always allowed for NULL representation
+	template <>
+	struct IsSupportedVariantType<std::monostate> : std::true_type
+	{
+	};
+
+	template <typename T>
+	inline constexpr bool isSupportedVariantTypeV = IsSupportedVariantType<T>::value;
+
+	///
+	/// Recursively validate all variant alternatives are supported.
+	///
+	template <typename V, std::size_t I = 0>
+	struct VariantAlternativesSupported : std::true_type
+	{
+	};
+
+	template <typename V, std::size_t I>
+	requires(I < std::variant_size_v<V>)
+	struct VariantAlternativesSupported<V, I>
+	{
+		using Alt = std::variant_alternative_t<I, V>;
+		static constexpr bool value = isSupportedVariantTypeV<Alt> && VariantAlternativesSupported<V, I + 1>::value;
+	};
+
+	template <typename V>
+	inline constexpr bool variantAlternativesSupportedV = VariantAlternativesSupported<V>::value;
+}  // namespace fbcpp::impl::reflection
+
+
+// Specializations for opaque type detection
+namespace fbcpp::impl::reflection
+{
+	template <>
+	struct IsOpaqueType<ScaledOpaqueInt128> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueDecFloat16> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueDecFloat34> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueDate> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueTime> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueTimestamp> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueTimeTz> : std::true_type
+	{
+	};
+
+	template <>
+	struct IsOpaqueType<OpaqueTimestampTz> : std::true_type
+	{
+	};
+}  // namespace fbcpp::impl::reflection
+
+
+#endif  // FBCPP_VARIANT_TYPE_TRAITS_H
diff --git a/src/test/Statement.cpp b/src/test/Statement.cpp
index 4dbca80..6699785 100644
--- a/src/test/Statement.cpp
+++ b/src/test/Statement.cpp
@@ -2828,3 +2828,483 @@ BOOST_AUTO_TEST_CASE(setTupleWithOptionalNull)
 }
 
 BOOST_AUTO_TEST_SUITE_END()
+
+
+BOOST_AUTO_TEST_SUITE(VariantSuite)
+
+BOOST_AUTO_TEST_CASE(getVariantNullReturnsMonostate)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t>;
+
+	const auto database = getTempFile("Statement-getVariantNullReturnsMonostate.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(null as integer) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_CHECK(std::holds_alternative<std::monostate>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantNullWithoutMonostateThrows)
+{
+	using MyVariant = std::variant<std::int32_t, std::string>;
+
+	const auto database = getTempFile("Statement-getVariantNullWithoutMonostateThrows.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(null as integer) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	BOOST_CHECK_THROW(stmt.get<MyVariant>(0), FbCppException);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantExactMatchInt32)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, double>;
+
+	const auto database = getTempFile("Statement-getVariantExactMatchInt32.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select 42 from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<std::int32_t>(result));
+	BOOST_CHECK_EQUAL(std::get<std::int32_t>(result), 42);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantExactMatchFloat)
+{
+	using MyVariant = std::variant<std::monostate, float, double>;
+
+	const auto database = getTempFile("Statement-getVariantExactMatchFloat.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(3.14 as float) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<float>(result));
+	BOOST_CHECK_CLOSE(std::get<float>(result), 3.14f, 0.01f);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantExactMatchString)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+
+	const auto database = getTempFile("Statement-getVariantExactMatchString.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select 'hello' from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<std::string>(result));
+	BOOST_CHECK_EQUAL(std::get<std::string>(result), "hello");
+}
+
+BOOST_AUTO_TEST_CASE(getVariantScaledIntPreferred)
+{
+	using MyVariant = std::variant<std::monostate, ScaledInt32, std::int32_t>;
+
+	const auto database = getTempFile("Statement-getVariantScaledIntPreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.45 as numeric(10, 2)) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<ScaledInt32>(result));
+	const auto scaled = std::get<ScaledInt32>(result);
+	BOOST_CHECK_EQUAL(scaled.value, 12345);
+	BOOST_CHECK_EQUAL(scaled.scale, -2);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantScaledIntFallback)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t>;
+
+	const auto database = getTempFile("Statement-getVariantScaledIntFallback.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(100.00 as numeric(10, 2)) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<std::int32_t>(result));
+	// When reading a scaled numeric as plain int, the library converts to scale 0
+	// so 100.00 becomes 100 (not the raw stored value 10000)
+	BOOST_CHECK_EQUAL(std::get<std::int32_t>(result), 100);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantScaledToLargerScaled)
+{
+	// NUMERIC(10,2) is INT32 with scale, but variant only has ScaledInt64
+	// Should use ScaledInt64 to preserve precision instead of falling back to int32
+	using MyVariant = std::variant<std::monostate, ScaledInt64, std::int32_t>;
+
+	const auto database = getTempFile("Statement-getVariantScaledToLargerScaled.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.45 as numeric(10, 2)) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<ScaledInt64>(result));
+	const auto scaled = std::get<ScaledInt64>(result);
+	BOOST_CHECK_EQUAL(scaled.value, 12345);
+	BOOST_CHECK_EQUAL(scaled.scale, -2);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantScaledToDouble)
+{
+	using MyVariant = std::variant<std::monostate, double>;
+
+	const auto database = getTempFile("Statement-getVariantScaledToDouble.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.45 as numeric(10, 2)) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<double>(result));
+	BOOST_CHECK_CLOSE(std::get<double>(result), 123.45, 0.01);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantFallbackToDouble)
+{
+	using MyVariant = std::variant<std::monostate, double>;
+
+	const auto database = getTempFile("Statement-getVariantFallbackToDouble.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select 42 from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<double>(result));
+	BOOST_CHECK_CLOSE(std::get<double>(result), 42.0, 0.01);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantFallbackOrder)
+{
+	using MyVariant = std::variant<std::monostate, std::int64_t, std::int32_t>;
+
+	const auto database = getTempFile("Statement-getVariantFallbackOrder.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(10 as smallint) from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	// int64 comes first in the variant, so it should be selected for the fallback
+	BOOST_REQUIRE(std::holds_alternative<std::int64_t>(result));
+	BOOST_CHECK_EQUAL(std::get<std::int64_t>(result), 10);
+}
+
+BOOST_AUTO_TEST_CASE(setVariantValue)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+
+	const auto database = getTempFile("Statement-setVariantValue.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(? as integer), cast(? as varchar(50)) from rdb$database"};
+
+	MyVariant intValue = 123;
+	MyVariant strValue = std::string{"test"};
+	stmt.set(0, intValue);
+	stmt.set(1, strValue);
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	BOOST_CHECK_EQUAL(stmt.getInt32(0).value(), 123);
+	BOOST_CHECK_EQUAL(stmt.getString(1).value(), "test");
+}
+
+BOOST_AUTO_TEST_CASE(setVariantMonostate)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t>;
+
+	const auto database = getTempFile("Statement-setVariantMonostate.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(? as integer) from rdb$database"};
+
+	MyVariant nullValue = std::monostate{};
+	stmt.set(0, nullValue);
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	BOOST_CHECK(!stmt.getInt32(0).has_value());
+}
+
+BOOST_AUTO_TEST_CASE(getTupleWithVariant)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+	using ResultTuple = std::tuple<std::int32_t, MyVariant>;
+
+	const auto database = getTempFile("Statement-getTupleWithVariant.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select 100, 'variant value' from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<ResultTuple>();
+	BOOST_CHECK_EQUAL(std::get<0>(result), 100);
+	BOOST_REQUIRE(std::holds_alternative<std::string>(std::get<1>(result)));
+	BOOST_CHECK_EQUAL(std::get<std::string>(std::get<1>(result)), "variant value");
+}
+
+BOOST_AUTO_TEST_CASE(getStructWithVariant)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+
+	struct Result
+	{
+		std::int32_t id;
+		MyVariant dynamicCol;
+	};
+
+	const auto database = getTempFile("Statement-getStructWithVariant.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select 42, 'dynamic' from rdb$database"};
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<Result>();
+	BOOST_CHECK_EQUAL(result.id, 42);
+	BOOST_REQUIRE(std::holds_alternative<std::string>(result.dynamicCol));
+	BOOST_CHECK_EQUAL(std::get<std::string>(result.dynamicCol), "dynamic");
+}
+
+BOOST_AUTO_TEST_CASE(setTupleWithVariant)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+	using ParamTuple = std::tuple<std::int32_t, MyVariant>;
+
+	const auto database = getTempFile("Statement-setTupleWithVariant.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(? as integer), cast(? as varchar(50)) from rdb$database"};
+
+	MyVariant strValue = std::string{"from tuple"};
+	stmt.set(ParamTuple{999, strValue});
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	BOOST_CHECK_EQUAL(stmt.getInt32(0).value(), 999);
+	BOOST_CHECK_EQUAL(stmt.getString(1).value(), "from tuple");
+}
+
+BOOST_AUTO_TEST_CASE(setStructWithVariant)
+{
+	using MyVariant = std::variant<std::monostate, std::int32_t, std::string>;
+
+	struct Params
+	{
+		std::int32_t id;
+		MyVariant dynamicCol;
+	};
+
+	const auto database = getTempFile("Statement-setStructWithVariant.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(? as integer), cast(? as varchar(50)) from rdb$database"};
+
+	Params params{888, std::string{"from struct"}};
+	stmt.set(params);
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	BOOST_CHECK_EQUAL(stmt.getInt32(0).value(), 888);
+	BOOST_CHECK_EQUAL(stmt.getString(1).value(), "from struct");
+}
+
+#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
+
+BOOST_AUTO_TEST_CASE(getVariantScaledOpaqueInt128Preferred)
+{
+	// When variant has both ScaledOpaqueInt128 and ScaledBoostInt128, prefer ScaledOpaqueInt128
+	using MyVariant = std::variant<std::monostate, ScaledOpaqueInt128, ScaledBoostInt128>;
+
+	const auto database = getTempFile("Statement-getVariantScaledOpaqueInt128Preferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.45 as numeric(38, 2)) from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<ScaledOpaqueInt128>(result));
+	const auto scaled = std::get<ScaledOpaqueInt128>(result);
+	BOOST_CHECK_EQUAL(scaled.scale, -2);
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueDecFloat16Preferred)
+{
+	// When variant has both OpaqueDecFloat16 and BoostDecFloat16, prefer OpaqueDecFloat16
+	using MyVariant = std::variant<std::monostate, OpaqueDecFloat16, BoostDecFloat16>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueDecFloat16Preferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.456 as decfloat(16)) from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueDecFloat16>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueDecFloat34Preferred)
+{
+	// When variant has both OpaqueDecFloat34 and BoostDecFloat34, prefer OpaqueDecFloat34
+	using MyVariant = std::variant<std::monostate, OpaqueDecFloat34, BoostDecFloat34>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueDecFloat34Preferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select cast(123.456 as decfloat(34)) from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueDecFloat34>(result));
+}
+
+#endif
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueDatePreferred)
+{
+	// When variant has both OpaqueDate and Date, prefer OpaqueDate
+	using MyVariant = std::variant<std::monostate, OpaqueDate, Date>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueDatePreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select date '2025-12-25' from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueDate>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueTimePreferred)
+{
+	// When variant has both OpaqueTime and Time, prefer OpaqueTime
+	using MyVariant = std::variant<std::monostate, OpaqueTime, Time>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueTimePreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select time '14:30:00' from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueTime>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueTimestampPreferred)
+{
+	// When variant has both OpaqueTimestamp and Timestamp, prefer OpaqueTimestamp
+	using MyVariant = std::variant<std::monostate, OpaqueTimestamp, Timestamp>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueTimestampPreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select timestamp '2025-12-25 14:30:00' from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueTimestamp>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueTimeTzPreferred)
+{
+	// When variant has both OpaqueTimeTz and TimeTz, prefer OpaqueTimeTz
+	using MyVariant = std::variant<std::monostate, OpaqueTimeTz, TimeTz>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueTimeTzPreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{attachment, transaction, "select time '14:30:00 America/New_York' from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueTimeTz>(result));
+}
+
+BOOST_AUTO_TEST_CASE(getVariantOpaqueTimestampTzPreferred)
+{
+	// When variant has both OpaqueTimestampTz and TimestampTz, prefer OpaqueTimestampTz
+	using MyVariant = std::variant<std::monostate, OpaqueTimestampTz, TimestampTz>;
+
+	const auto database = getTempFile("Statement-getVariantOpaqueTimestampTzPreferred.fdb");
+	Attachment attachment{CLIENT, database, AttachmentOptions().setCreateDatabase(true)};
+	FbDropDatabase attachmentDrop{attachment};
+
+	Transaction transaction{attachment};
+	Statement stmt{
+		attachment, transaction, "select timestamp '2025-12-25 14:30:00 America/New_York' from rdb$database"};
+
+	BOOST_REQUIRE(stmt.execute(transaction));
+
+	const auto result = stmt.get<MyVariant>(0);
+	BOOST_REQUIRE(std::holds_alternative<OpaqueTimestampTz>(result));
+}
+
+BOOST_AUTO_TEST_SUITE_END()