Add JNI Variant extraction support

src/main/cpp/CMakeLists.txt

@@ -230,6 +230,7 @@ add_library(
   src/StringUtilsJni.cpp
   src/SubStringIndexJni.cpp
   src/TaskPriorityJni.cpp
+  src/VariantUtilsJni.cpp
   src/ZOrderJni.cpp
   src/iceberg/IcebergBucketJni.cpp
   src/iceberg/IcebergDateTimeUtilJni.cpp

src/main/cpp/src/VariantUtilsJni.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2026, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cudf_jni_apis.hpp"
+#include "jni_utils.hpp"
+
+#include <cudf/io/experimental/variant.hpp>
+#include <cudf/types.hpp>
+#include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/memory_resource.hpp>
+
+extern "C" {
+
+JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_VariantUtils_getVariantFieldValue(
+  JNIEnv* env, jclass, jlong variant_struct_handle, jstring j_path)
+{
+  JNI_NULL_CHECK(env, variant_struct_handle, "variant struct column is null", 0);
+  JNI_NULL_CHECK(env, j_path, "path is null", 0);
+  JNI_TRY
+  {
+    cudf::jni::auto_set_device(env);
+    auto const& variant_struct = *reinterpret_cast<cudf::column_view const*>(variant_struct_handle);
+    cudf::jni::native_jstring path(env, j_path);
+    return cudf::jni::release_as_jlong(
+      cudf::io::parquet::experimental::get_variant_field(variant_struct,
+                                                         path.get(),
+                                                         cudf::get_default_stream(),
+                                                         cudf::get_current_device_resource_ref()));
+  }
+  JNI_CATCH(env, 0);
+}
+
+JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_VariantUtils_castVariantValue(
+  JNIEnv* env, jclass, jlong value_bytes_handle, jint cudf_type_id)
+{
+  JNI_NULL_CHECK(env, value_bytes_handle, "value bytes column is null", 0);
+  JNI_TRY
+  {
+    cudf::jni::auto_set_device(env);
+    auto const& value_bytes = *reinterpret_cast<cudf::column_view const*>(value_bytes_handle);
+    return cudf::jni::release_as_jlong(cudf::io::parquet::experimental::cast_variant(
+      value_bytes,
+      cudf::data_type{static_cast<cudf::type_id>(cudf_type_id)},
+      cudf::get_default_stream(),
+      cudf::get_current_device_resource_ref()));
+  }
+  JNI_CATCH(env, 0);
+}
+
+JNIEXPORT jlong JNICALL Java_com_nvidia_spark_rapids_jni_VariantUtils_extractVariantField(
+  JNIEnv* env, jclass, jlong variant_struct_handle, jstring j_path, jint cudf_type_id)
+{
+  JNI_NULL_CHECK(env, variant_struct_handle, "variant struct column is null", 0);
+  JNI_NULL_CHECK(env, j_path, "path is null", 0);
+  JNI_TRY
+  {
+    cudf::jni::auto_set_device(env);
+    auto const& variant_struct = *reinterpret_cast<cudf::column_view const*>(variant_struct_handle);
+    cudf::jni::native_jstring path(env, j_path);
+    return cudf::jni::release_as_jlong(cudf::io::parquet::experimental::extract_variant_field(
+      variant_struct,
+      path.get(),
+      cudf::data_type{static_cast<cudf::type_id>(cudf_type_id)},
+      cudf::get_default_stream(),
+      cudf::get_current_device_resource_ref()));
+  }
+  JNI_CATCH(env, 0);
+}
+
+JNIEXPORT jboolean JNICALL Java_com_nvidia_spark_rapids_jni_VariantUtils_isAvailableNative(JNIEnv*,
+                                                                                           jclass)
+{
+  return JNI_TRUE;
+}
+
+}  // extern "C"

src/main/java/com/nvidia/spark/rapids/jni/VariantUtils.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.nvidia.spark.rapids.jni;
+
+import ai.rapids.cudf.ColumnVector;
+import ai.rapids.cudf.ColumnView;
+import ai.rapids.cudf.DType;
+import ai.rapids.cudf.NativeDepsLoader;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * JNI bridge to cuDF's experimental Parquet Variant field extraction APIs.
+ */
+public class VariantUtils {
+  static {
+    NativeDepsLoader.loadNativeDeps();
+  }
+
+  private static final List<DType> SUPPORTED_TYPES = Arrays.asList(
+      DType.STRING, DType.INT8, DType.INT16, DType.INT32, DType.INT64);
+
+  private VariantUtils() {}
+
+  private static void validateTargetType(DType targetType) {
+    Objects.requireNonNull(targetType, "targetType");
+    if (!SUPPORTED_TYPES.contains(targetType)) {
+      throw new IllegalArgumentException("unsupported Variant target type: " + targetType +
+          "; supported types are " + SUPPORTED_TYPES);
+    }
+  }
+
+  /**
+   * Extract raw Variant-encoded value bytes at {@code path} from a Variant struct column.
+   *
+   * @param variantStruct Variant materialization: STRUCT(metadata LIST&lt;UINT8&gt;,
+   *                      value LIST&lt;UINT8&gt;, optional shredded children...)
+   * @param path JSONPath-like path accepted by cuDF's Variant extractor. Paths are expected to
+   *             be ASCII object-field paths like {@code x}, {@code $.x}, or {@code $.x.y}.
+   * @return LIST&lt;UINT8&gt; column of raw encoded Variant values
+   */
+  public static ColumnVector getVariantFieldValue(ColumnView variantStruct, String path) {
+    Objects.requireNonNull(variantStruct, "variantStruct");
+    Objects.requireNonNull(path, "path");
+    return new ColumnVector(getVariantFieldValue(variantStruct.getNativeView(), path));
+  }
+
+  /**
+   * Decode raw Variant-encoded value bytes into {@code targetType}. Supported target types are
+   * {@link DType#STRING}, {@link DType#INT8}, {@link DType#INT16}, {@link DType#INT32}, and
+   * {@link DType#INT64}.
+   */
+  public static ColumnVector castVariantValue(ColumnView valueBytes, DType targetType) {
+    Objects.requireNonNull(valueBytes, "valueBytes");
+    validateTargetType(targetType);
+    return new ColumnVector(castVariantValue(
+        valueBytes.getNativeView(), targetType.getTypeId().getNativeId()));
+  }
+
+  /**
+   * Extract a Variant field and decode it into {@code targetType} in one native call.
+   * Supported target types are {@link DType#STRING}, {@link DType#INT8}, {@link DType#INT16},
+   * {@link DType#INT32}, and {@link DType#INT64}.
+   */
+  public static ColumnVector extractVariantField(
+      ColumnView variantStruct, String path, DType targetType) {
+    Objects.requireNonNull(variantStruct, "variantStruct");
+    Objects.requireNonNull(path, "path");
+    validateTargetType(targetType);
+    return new ColumnVector(extractVariantField(
+        variantStruct.getNativeView(), path, targetType.getTypeId().getNativeId()));
+  }
+
+  /**
+   * Returns true when the loaded JNI library exposes the Variant extraction entry points.
+   */
+  public static boolean isAvailable() {
+    try {
+      return isAvailableNative();
+    } catch (UnsatisfiedLinkError e) {
+      return false;
+    }
+  }
+
+  private static native long getVariantFieldValue(long variantStructHandle, String path);
+
+  private static native long castVariantValue(long valueBytesHandle, int cudfTypeId);
+
+  private static native long extractVariantField(
+      long variantStructHandle, String path, int cudfTypeId);
+
+  private static native boolean isAvailableNative();
+}