Fix compile errors from merging Dataset Specs (#2858)

Semantic conflicts between this PR and #2858 broke the build after the
upstream/main merge:

- detail/pq.cuh: vpq_build returns device_vpq_dataset<StoreMathT, IdxT>
  again. Our edit to the adjacent signature line had taken precedence in
  the conflict resolution and dropped #2858's return-type fix.
- pq.hpp: the dataset branch of make_device_pq_dataset uses the new
  dataset_view API (data_const_view(), dim()) instead of the removed
  view()/stride()/extent()/data_handle(). Doc example uses view().
- tiered_index.cu: call cagra::detail::convert_standard_to_padded_index,
  since the public declaration was removed by this PR.
- test_float_uint32_t.cu: as_dataset_view() -> view().

Author: HowardHuang1

cpp/include/cuvs/preprocessing/quantize/pq.hpp

@@ -271,8 +271,8 @@ namespace detail {
  *
  * Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same
  * pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset
- * view exposing `data_const_view`, in which case the logical `dim()` is quantized and the row
- * padding is skipped. The rows may be device-accessible or host-resident. Device-accessible
+ * view exposing `data_const_view` and `dim`, in which case the logical `dim()` is quantized and the
+ * row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible
  * rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension)
  * are passed through to training as they are; a wider row pitch triggers a contiguous dense copy
  * first. Host-resident rows are subsampled for training and encoded in bounded batches, so the
@@ -294,8 +294,8 @@ namespace detail {
  * Keep the `device_vpq_dataset` alive; the index holds a non-owning view.
  *
  * auto pq = cuvs::preprocessing::quantize::pq::make_device_pq_dataset(res, pq_params, padded);
- * auto pq_idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), pq.as_dataset_view());
- * // or: auto idx = cuvs::neighbors::cagra::build(res, cagra_params, pq.as_dataset_view());
+ * auto pq_idx = cuvs::neighbors::cagra::update_dataset(res, std::move(idx), pq.view());
+ * // or: auto idx = cuvs::neighbors::cagra::build(res, cagra_params, pq.view());
  * @endcode
  */
 template <typename SrcT>
@@ -304,13 +304,12 @@ template <typename SrcT>
                                           SrcT const& src)
   -> cuvs::neighbors::device_vpq_dataset<half, int64_t>
 {
-  // A cuVS dataset keeps its logical width in `dim()` while `view()` spans the full row pitch.
+  // A cuVS dataset keeps its logical width in `dim()` while its data view spans the full row pitch.
   if constexpr (requires {
-                  src.view();
+                  src.data_const_view();
                   src.dim();
-                  src.stride();
                 }) {
-    auto const rows    = src.view();
+    auto const rows    = src.data_const_view();
     using value_type   = typename decltype(rows)::value_type;
     using extents_type = raft::matrix_extent<int64_t>;
     return make_device_pq_dataset(
@@ -319,7 +318,7 @@ template <typename SrcT>
       raft::mdspan<const value_type, extents_type, raft::layout_stride>{
         rows.data_handle(),
         raft::make_strided_layout(extents_type{rows.extent(0), int64_t{src.dim()}},
-                                  cuda::std::array<int64_t, 2>{int64_t{src.stride()}, 1})});
+                                  cuda::std::array<int64_t, 2>{int64_t{rows.stride(0)}, 1})});
   } else {
     using value_type = typename SrcT::value_type;
     static_assert(std::is_same_v<value_type, float> || std::is_same_v<value_type, half> ||

cpp/src/neighbors/tiered_index.cu

@@ -100,7 +100,7 @@ auto convert_standard_to_padded_index(
       static_cast<int64_t>(idx.state->ann_rows()),
       padded_dataset.dim(),
       padded_mds.stride(0));
-    auto ann_padded_idx = cuvs::neighbors::cagra::convert_standard_to_padded_index(
+    auto ann_padded_idx = cuvs::neighbors::cagra::detail::convert_standard_to_padded_index(
       res, *idx.state->ann_index, ann_padded_view);
     next_state->ann_index =
       std::make_shared<cuvs::neighbors::cagra::device_padded_index<float, uint32_t>>(

cpp/src/preprocessing/quantize/detail/pq.cuh

@@ -338,7 +338,7 @@ void inverse_transform(
 template <typename DatasetT, typename MathT, typename IdxT, typename StoreMathT = MathT>
 auto vpq_build(const raft::resources& res,
                const cuvs::preprocessing::quantize::pq::params& params,
-               const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<MathT, IdxT>
+               const DatasetT& dataset) -> cuvs::neighbors::device_vpq_dataset<StoreMathT, IdxT>
 {
   using label_t = uint32_t;
   auto ps       = params;

cpp/tests/neighbors/ann_cagra/test_float_uint32_t.cu

@@ -186,7 +186,7 @@ TEST(AnnCagraPq, BuildUpdatePqSearch)
   EXPECT_EQ(pq.n_rows(), n_rows);
   EXPECT_EQ(pq.dim(), dim);
 
-  auto pq_index = cagra::update_dataset(handle, std::move(dense_index), pq.as_dataset_view());
+  auto pq_index = cagra::update_dataset(handle, std::move(dense_index), pq.view());
 
   auto queries = raft::make_device_matrix<float, int64_t>(handle, n_queries, dim);
   raft::copy(queries.data_handle(), dataset.data_handle(), queries.size(), stream);

fern/pages/cpp_api/cpp-api-preprocessing-quantize-pq.md

@@ -267,7 +267,7 @@ SrcT const& src)
 -> cuvs::neighbors::device_vpq_dataset<half, int64_t>;
 ```
 
-Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset view exposing `data_const_view`, in which case the logical `dim()` is quantized and the row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension) are passed through to training as they are; a wider row pitch triggers a contiguous dense copy first. Host-resident rows are subsampled for training and encoded in bounded batches, so the dense dataset is never staged on the device in full; they must be tightly packed. Empty sources are rejected. The element type must be `float`, `half`, `int8_t` or `uint8_t`.
+Accepts either a row-major mdspan with `value_type`, `extent`, `stride`, and `data_handle` (same pattern as `cuvs::neighbors::make_device_padded_dataset`), or any cuVS dense dataset / dataset view exposing `data_const_view` and `dim`, in which case the logical `dim()` is quantized and the row padding is skipped. The rows may be device-accessible or host-resident. Device-accessible rows (device, managed or pinned) with tight row-major storage (logical stride equals dimension) are passed through to training as they are; a wider row pitch triggers a contiguous dense copy first. Host-resident rows are subsampled for training and encoded in bounded batches, so the dense dataset is never staged on the device in full; they must be tightly packed. Empty sources are rejected. The element type must be `float`, `half`, `int8_t` or `uint8_t`.
 
 Typical **CAGRA** usage: build the graph on dense vectors, then attach PQ for search (metric must remain `L2Expanded` for this path). Train PQ from the same CAGRA-padded device layout you used for graph build, keep the `device_vpq_dataset` alive, and call `cagra::update_dataset` with a non-owning view.