Restructure JSON code to correctly reflect legacy/experimental status

cpp/CMakeLists.txt

@@ -371,12 +371,12 @@ add_library(
   src/io/csv/writer_impl.cu
   src/io/functions.cpp
   src/io/json/json_column.cu
-  src/io/json/json_gpu.cu
+  src/io/json/legacy/json_gpu.cu
   src/io/json/json_tree.cu
   src/io/json/nested_json_gpu.cu
-  src/io/json/reader_impl.cu
-  src/io/json/experimental/byte_range_info.cu
-  src/io/json/experimental/read_json.cu
+  src/io/json/read_json.cu
+  src/io/json/byte_range_info.cu
+  src/io/json/legacy/reader_impl.cu
   src/io/json/write_json.cu
   src/io/orc/aggregate_orc_metadata.cpp
   src/io/orc/dict_enc.cu

cpp/include/cudf/io/detail/data_casting.cuh

@@ -32,7 +32,7 @@
 
 #include <memory>
 
-namespace cudf::io::json::experimental::detail {
+namespace cudf::io::json::detail {
 
 // Unicode code point escape sequence
 static constexpr char UNICODE_SEQ = 0x7F;
@@ -428,4 +428,4 @@ std::unique_ptr<column> parse_data(str_tuple_it str_tuples,
   return out_col;
 }
 
-}  // namespace cudf::io::json::experimental::detail
+}  // namespace cudf::io::json::detail

cpp/include/cudf/io/detail/json.hpp

@@ -33,7 +33,7 @@ namespace cudf::io::json::detail {
  *
  * @return cudf::table object that contains the array of cudf::column.
  */
-table_with_metadata read_json(std::vector<std::unique_ptr<cudf::io::datasource>>& sources,
+table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
                               json_reader_options const& options,
                               rmm::cuda_stream_view stream,
                               rmm::mr::device_memory_resource* mr);

cpp/src/io/json/experimental/byte_range_info.cu → cpp/src/io/json/byte_range_info.cu

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, NVIDIA CORPORATION.
+ * Copyright (c) 2022-2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
 #include <rmm/exec_policy.hpp>
 #include <thrust/find.h>
 
-namespace cudf::io::detail::json::experimental {
+namespace cudf::io::json::detail {
 
 // Extract the first character position in the string.
 size_type find_first_delimiter(device_span<char const> d_data,
@@ -33,4 +33,4 @@ size_type find_first_delimiter(device_span<char const> d_data,
   return first_delimiter_position != d_data.end() ? first_delimiter_position - d_data.begin() : -1;
 }
 
-}  // namespace cudf::io::detail::json::experimental
+}  // namespace cudf::io::json::detail

cpp/src/io/json/json_column.cu

@@ -52,8 +52,7 @@
 #include <algorithm>
 #include <cstdint>
 
-namespace cudf::io::json {
-namespace detail {
+namespace cudf::io::json::detail {
 
 // DEBUG prints
 auto to_cat = [](auto v) -> std::string {
@@ -348,14 +347,14 @@ std::vector<std::string> copy_strings_to_host(device_span<SymbolT const> input,
   cudf::io::parse_options_view options_view{};
   options_view.quotechar  = '\0';  // no quotes
   options_view.keepquotes = true;
-  auto d_column_names     = experimental::detail::parse_data(string_views.begin(),
-                                                         num_strings,
-                                                         data_type{type_id::STRING},
-                                                         rmm::device_buffer{},
-                                                         0,
-                                                         options_view,
-                                                         stream,
-                                                         rmm::mr::get_current_device_resource());
+  auto d_column_names     = parse_data(string_views.begin(),
+                                   num_strings,
+                                   data_type{type_id::STRING},
+                                   rmm::device_buffer{},
+                                   0,
+                                   options_view,
+                                   stream,
+                                   rmm::mr::get_current_device_resource());
   auto to_host            = [](auto const& col) {
     if (col.is_empty()) return std::vector<std::string>{};
     auto const scv     = cudf::strings_column_view(col);
@@ -796,14 +795,14 @@ std::pair<std::unique_ptr<column>, std::vector<column_name_info>> device_json_co
 
       auto [result_bitmask, null_count] = make_validity(json_col);
       // Convert strings to the inferred data type
-      auto col = experimental::detail::parse_data(string_spans_it,
-                                                  col_size,
-                                                  target_type,
-                                                  std::move(result_bitmask),
-                                                  null_count,
-                                                  options.view(),
-                                                  stream,
-                                                  mr);
+      auto col = parse_data(string_spans_it,
+                            col_size,
+                            target_type,
+                            std::move(result_bitmask),
+                            null_count,
+                            options.view(),
+                            stream,
+                            mr);
 
       // Reset nullable if we do not have nulls
       // This is to match the existing JSON reader's behaviour:
@@ -1044,5 +1043,4 @@ table_with_metadata device_parse_nested_json(device_span<SymbolT const> d_input,
   return table_with_metadata{std::make_unique<table>(std::move(out_columns)), {out_column_names}};
 }
 
-}  // namespace detail
-}  // namespace cudf::io::json
+}  // namespace cudf::io::json::detail

cpp/src/io/json/json_gpu.cu → cpp/src/io/json/legacy/json_gpu.cu

@@ -45,11 +45,7 @@
 
 using cudf::device_span;
 
-namespace cudf {
-namespace io {
-namespace json {
-namespace gpu {
-using namespace ::cudf;
+namespace cudf::io::json::detail::legacy {
 
 namespace {
 /**
@@ -515,7 +511,7 @@ __global__ void collect_keys_info_kernel(parse_options_view const options,
 }  // namespace
 
 /**
- * @copydoc cudf::io::json::gpu::convert_json_to_columns
+ * @copydoc cudf::io::json::detail::legacy::convert_json_to_columns
  */
 void convert_json_to_columns(parse_options_view const& opts,
                              device_span<char const> const data,
@@ -547,7 +543,7 @@ void convert_json_to_columns(parse_options_view const& opts,
 }
 
 /**
- * @copydoc cudf::io::gpu::detect_data_types
+ * @copydoc cudf::io::json::detail::legacy::detect_data_types
  */
 
 std::vector<cudf::io::column_type_histogram> detect_data_types(
@@ -592,7 +588,7 @@ std::vector<cudf::io::column_type_histogram> detect_data_types(
 }
 
 /**
- * @copydoc cudf::io::json::gpu::gpu_collect_keys_info
+ * @copydoc cudf::io::json::detail::legacy::collect_keys_info
  */
 void collect_keys_info(parse_options_view const& options,
                        device_span<char const> const data,
@@ -615,7 +611,4 @@ void collect_keys_info(parse_options_view const& options,
   CUDF_CHECK_CUDA(stream.value());
 }
 
-}  // namespace gpu
-}  // namespace json
-}  // namespace io
-}  // namespace cudf
+}  // namespace cudf::io::json::detail::legacy

cpp/src/io/json/json_gpu.hpp → cpp/src/io/json/legacy/json_gpu.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2022, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2023, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,10 +31,7 @@
 
 using cudf::device_span;
 
-namespace cudf {
-namespace io {
-namespace json {
-namespace gpu {
+namespace cudf::io::json::detail::legacy {
 
 using col_map_type = concurrent_unordered_map<uint32_t, cudf::size_type>;
 /**
@@ -100,7 +97,4 @@ void collect_keys_info(parse_options_view const& options,
                        thrust::optional<mutable_table_device_view> keys_info,
                        rmm::cuda_stream_view stream);
 
-}  // namespace gpu
-}  // namespace json
-}  // namespace io
-}  // namespace cudf
+}  // namespace cudf::io::json::detail::legacy

cpp/src/io/json/legacy/read_json.hpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023, 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/types.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <thrust/mr/memory_resource.h>
+
+#include <memory>
+#include <vector>
+
+namespace cudf::io::json::detail::legacy {
+
+table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
+                              json_reader_options const& reader_opts,
+                              rmm::cuda_stream_view stream,
+                              rmm::mr::device_memory_resource* mr);
+
+}  // namespace cudf::io::json::detail::legacy

cpp/src/io/json/reader_impl.cu → cpp/src/io/json/legacy/reader_impl.cu

@@ -16,8 +16,6 @@
 
 #include "json_gpu.hpp"
 
-#include "experimental/read_json.hpp"
-
 #include <hash/concurrent_unordered_map.cuh>
 
 #include <io/comp/io_uncomp.hpp>
@@ -56,9 +54,8 @@
 
 using cudf::host_span;
 
-namespace cudf::io::json::detail {
+namespace cudf::io::json::detail::legacy {
 
-using col_map_type     = cudf::io::json::gpu::col_map_type;
 using col_map_ptr_type = std::unique_ptr<col_map_type, std::function<void(col_map_type*)>>;
 
 /**
@@ -129,8 +126,7 @@ std::unique_ptr<table> create_json_keys_info_table(parse_options_view const& par
 {
   // Count keys
   rmm::device_scalar<unsigned long long int> key_counter(0, stream);
-  cudf::io::json::gpu::collect_keys_info(
-    parse_opts, data, row_offsets, key_counter.data(), {}, stream);
+  collect_keys_info(parse_opts, data, row_offsets, key_counter.data(), {}, stream);
 
   // Allocate columns to store hash value, length, and offset of each JSON object key in the input
   auto const num_keys = key_counter.value(stream);
@@ -148,8 +144,7 @@ std::unique_ptr<table> create_json_keys_info_table(parse_options_view const& par
   // Reset the key counter - now used for indexing
   key_counter.set_value_to_zero_async(stream);
   // Fill the allocated columns
-  cudf::io::json::gpu::collect_keys_info(
-    parse_opts, data, row_offsets, key_counter.data(), {*info_table_mdv}, stream);
+  collect_keys_info(parse_opts, data, row_offsets, key_counter.data(), {*info_table_mdv}, stream);
   return info_table;
 }
 
@@ -213,7 +208,7 @@ std::pair<std::vector<std::string>, col_map_ptr_type> get_json_object_keys_hashe
           create_col_names_hash_map(sorted_info->get_column(2).view(), stream)};
 }
 
-std::vector<uint8_t> ingest_raw_input(std::vector<std::unique_ptr<datasource>> const& sources,
+std::vector<uint8_t> ingest_raw_input(host_span<std::unique_ptr<datasource>> sources,
                                       compression_type compression,
                                       size_t range_offset,
                                       size_t range_size,
@@ -447,7 +442,7 @@ std::vector<data_type> get_data_types(json_reader_options const& reader_opts,
     auto const num_columns       = column_names.size();
     auto const do_set_null_count = column_map->capacity() > 0;
 
-    auto const h_column_infos = cudf::io::json::gpu::detect_data_types(
+    auto const h_column_infos = detect_data_types(
       parse_opts, data, rec_starts, do_set_null_count, num_columns, column_map, stream);
 
     auto get_type_id = [&](auto const& cinfo) {
@@ -523,7 +518,7 @@ table_with_metadata convert_data_to_table(parse_options_view const& parse_opts,
   auto d_valid_counts = cudf::detail::make_zeroed_device_uvector_async<cudf::size_type>(
     num_columns, stream, rmm::mr::get_current_device_resource());
 
-  cudf::io::json::gpu::convert_json_to_columns(
+  convert_json_to_columns(
     parse_opts, data, rec_starts, d_dtypes, column_map, d_data, d_valid, d_valid_counts, stream);
 
   stream.synchronize();
@@ -591,16 +586,11 @@ table_with_metadata convert_data_to_table(parse_options_view const& parse_opts,
  *
  * @return Table and its metadata
  */
-table_with_metadata read_json(std::vector<std::unique_ptr<datasource>>& sources,
+table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
                               json_reader_options const& reader_opts,
                               rmm::cuda_stream_view stream,
                               rmm::mr::device_memory_resource* mr)
 {
-  CUDF_FUNC_RANGE();
-  if (not reader_opts.is_enabled_legacy()) {
-    return cudf::io::detail::json::experimental::read_json(sources, reader_opts, stream, mr);
-  }
-
   CUDF_EXPECTS(not sources.empty(), "No sources were defined");
   CUDF_EXPECTS(sources.size() == 1 or reader_opts.get_compression() == compression_type::NONE,
                "Multiple compressed inputs are not supported");
@@ -664,4 +654,4 @@ table_with_metadata read_json(std::vector<std::unique_ptr<datasource>>& sources,
                                mr);
 }
 
-}  // namespace cudf::io::json::detail
+}  // namespace cudf::io::json::detail::legacy

cpp/src/io/json/nested_json_gpu.cu

@@ -1993,14 +1993,14 @@ std::pair<std::unique_ptr<column>, std::vector<column_name_info>> json_column_to
       auto [result_bitmask, null_count] = make_validity(json_col);
 
       // Convert strings to the inferred data type
-      auto col = experimental::detail::parse_data(string_spans_it,
-                                                  col_size,
-                                                  target_type,
-                                                  std::move(result_bitmask),
-                                                  null_count,
-                                                  parsing_options(options).view(),
-                                                  stream,
-                                                  mr);
+      auto col = parse_data(string_spans_it,
+                            col_size,
+                            target_type,
+                            std::move(result_bitmask),
+                            null_count,
+                            parsing_options(options).view(),
+                            stream,
+                            mr);
 
       // Reset nullable if we do not have nulls
       // This is to match the existing JSON reader's behaviour:

cpp/src/io/json/experimental/read_json.cu → cpp/src/io/json/read_json.cu

@@ -17,6 +17,7 @@
 #include "read_json.hpp"
 
 #include <io/comp/io_uncomp.hpp>
+#include <io/json/legacy/read_json.hpp>
 #include <io/json/nested_json.hpp>
 
 #include <cudf/detail/nvtx/ranges.hpp>
@@ -30,7 +31,7 @@
 
 #include <numeric>
 
-namespace cudf::io::detail::json::experimental {
+namespace cudf::io::json::detail {
 
 size_t sources_size(host_span<std::unique_ptr<datasource>> const sources,
                     size_t range_offset,
@@ -44,7 +45,7 @@ size_t sources_size(host_span<std::unique_ptr<datasource>> const sources,
   });
 }
 
-rmm::device_uvector<char> ingest_raw_input(host_span<std::unique_ptr<datasource>> const& sources,
+rmm::device_uvector<char> ingest_raw_input(host_span<std::unique_ptr<datasource>> sources,
                                            compression_type compression,
                                            size_t range_offset,
                                            size_t range_size,
@@ -197,6 +198,11 @@ table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
                               rmm::mr::device_memory_resource* mr)
 {
   CUDF_FUNC_RANGE();
+
+  if (reader_opts.is_enabled_legacy()) {
+    return cudf::io::json::detail::legacy::read_json(sources, reader_opts, stream, mr);
+  }
+
   if (not should_load_whole_source(reader_opts)) {
     CUDF_EXPECTS(reader_opts.is_enabled_lines(),
                  "Specifying a byte range is supported only for JSON Lines");
@@ -213,8 +219,8 @@ table_with_metadata read_json(host_span<std::unique_ptr<datasource>> sources,
 
   auto const buffer = get_record_range_raw_input(sources, reader_opts, stream);
 
-  return cudf::io::json::detail::device_parse_nested_json(buffer, reader_opts, stream, mr);
+  return device_parse_nested_json(buffer, reader_opts, stream, mr);
   // For debug purposes, use host_parse_nested_json()
 }
 
-}  // namespace cudf::io::detail::json::experimental
+}  // namespace cudf::io::json::detail