cast_variant skips unsupported target type validation for empty inputs

cpp/src/io/parquet/experimental/variant_extract.cu

@@ -698,6 +698,20 @@ void validate_variant_child(column_view const& child)
                std::invalid_argument);
 }
 
+struct validate_variant_type_fn {
+  template <typename T>
+  void operator()()
+    requires(is_variant_castable<T>)
+  {
+  }
+  template <typename T>
+  void operator()()
+    requires(not is_variant_castable<T>)
+  {
+    CUDF_FAIL("unsupported type for variant cast", std::invalid_argument);
+  }
+};
+
 struct cast_variant_fn {
   cudf::lists_column_device_view values;
   size_type num_rows;
@@ -886,6 +900,7 @@ std::unique_ptr<column> cast_variant(column_view const& values,
                                      rmm::device_async_resource_ref mr)
 {
   validate_variant_child(values);
+  cudf::type_dispatcher(desired_type, validate_variant_type_fn{});
   size_type const num_rows = values.size();
   if (num_rows == 0) { return make_empty_column(desired_type); }
 

cpp/tests/io/experimental/variant_extract_test.cpp

@@ -18,6 +18,7 @@
 #include <cudf/utilities/span.hpp>
 
 #include <array>
+#include <bit>
 #include <cstdio>
 #include <cstring>
 #include <memory>
@@ -1032,11 +1033,9 @@ TEST_F(CastVariantTest, EmptyInput)
   }
 }
 
-TEST_F(CastVariantTest, CastToUnsupportedTargetThrows)
+TEST_F(CastVariantTest, UnsupportedTypeThrows)
 {
-  // cast_variant only supports INT8/16/32/64 and STRING targets. Every other target is rejected at
-  // compile-time dispatch on the requested output type, independent of the input bytes, so a single
-  // well-formed placeholder row triggers the same throw for all of them.
+  // Unsupported target types must throw regardless of whether the input is empty or non-empty.
   auto stream = cudf::test::get_default_stream();
   std::vector<uint8_t> const val{make_variant_primitive(variant_primitive_type::NULLVAL)};
   cudf::test::lists_column_wrapper<uint8_t> values(val.begin(), val.end());
@@ -1053,11 +1052,24 @@ TEST_F(CastVariantTest, CastToUnsupportedTargetThrows)
                                        cudf::type_id::DECIMAL64,
                                        cudf::type_id::DECIMAL128};
 
+  // Empty input: the early-return path must still validate the type.
+  auto const empty_values =
+    cudf::empty_like(cudf::structs_column_view{make_xyz_three_row_variant()}.child(1));
+  for (auto const& id : ids) {
+    EXPECT_THROW(static_cast<void>(cudf::io::parquet::experimental::cast_variant(
+                   *empty_values, cudf::data_type{id}, stream)),
+                 std::invalid_argument)
+      << "expected throw for type_id " << static_cast<int>(id) << " on empty input";
+  }
+
+  // Non-empty input: the dispatch path must also throw for unsupported types.
+  auto col         = make_apache_variant(avf::primitive_int32);
+  auto const value = cudf::structs_column_view{col}.get_sliced_child(1, stream);
   for (auto const id : ids) {
-    SCOPED_TRACE(std::string{"target type_id: "} + std::to_string(static_cast<int32_t>(id)));
     EXPECT_THROW(static_cast<void>(cudf::io::parquet::experimental::cast_variant(
-                   values, cudf::data_type{id}, stream)),
-                 std::invalid_argument);
+                   value, cudf::data_type{id}, stream)),
+                 std::invalid_argument)
+      << "expected throw for type_id " << static_cast<int>(id) << " on non-empty input";
   }
 }