scalar.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-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.
 */
#pragma once
 
#include <cudf/column/column.hpp>
#include <cudf/table/table.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/traits.hpp>
 
#include <rmm/cuda_stream_view.hpp>
#include <rmm/device_buffer.hpp>
#include <rmm/device_scalar.hpp>
#include <rmm/mr/device/per_device_resource.hpp>
 
namespace cudf {
class scalar {
 public:
  virtual ~scalar()                      = default;
  scalar& operator=(scalar const& other) = delete;
  scalar& operator=(scalar&& other)      = delete;
 
  [[nodiscard]] data_type type() const noexcept;
 
  void set_valid_async(bool is_valid, rmm::cuda_stream_view stream = cudf::get_default_stream());
 
  [[nodiscard]] bool is_valid(rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  bool* validity_data();
 
  [[nodiscard]] bool const* validity_data() const;
 
 protected:
  data_type _type{type_id::EMPTY};     
  rmm::device_scalar<bool> _is_valid;  
 
  scalar() = delete;
 
  scalar(scalar&& other) = default;
 
  scalar(scalar const& other,
         rmm::cuda_stream_view stream        = cudf::get_default_stream(),
         rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  scalar(data_type type,
         bool is_valid                       = false,
         rmm::cuda_stream_view stream        = cudf::get_default_stream(),
         rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
};
 
namespace detail {
template <typename T>
class fixed_width_scalar : public scalar {
  static_assert(is_fixed_width<T>(), "Unexpected non-fixed-width type.");
 
 public:
  using value_type = T;  
 
  ~fixed_width_scalar() override = default;
 
  fixed_width_scalar(fixed_width_scalar&& other) = default;
 
  fixed_width_scalar& operator=(fixed_width_scalar const& other) = delete;
  fixed_width_scalar& operator=(fixed_width_scalar&& other)      = delete;
 
  fixed_width_scalar(fixed_width_scalar const& other,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  void set_value(T value, rmm::cuda_stream_view stream = cudf::get_default_stream());
 
  explicit operator value_type() const;
 
  T value(rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  T* data();
 
  T const* data() const;
 
 protected:
  rmm::device_scalar<T> _data;  
 
  fixed_width_scalar() = delete;
 
  fixed_width_scalar(T value,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  fixed_width_scalar(rmm::device_scalar<T>&& data,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
};
 
}  // namespace detail
 
template <typename T>
class numeric_scalar : public detail::fixed_width_scalar<T> {
  static_assert(is_numeric<T>(), "Unexpected non-numeric type.");
 
 public:
  numeric_scalar()  = delete;
  ~numeric_scalar() = default;
 
  numeric_scalar(numeric_scalar&& other) = default;
 
  numeric_scalar& operator=(numeric_scalar const& other) = delete;
  numeric_scalar& operator=(numeric_scalar&& other)      = delete;
 
  numeric_scalar(numeric_scalar const& other,
                 rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                 rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  numeric_scalar(T value,
                 bool is_valid                       = true,
                 rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                 rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  numeric_scalar(rmm::device_scalar<T>&& data,
                 bool is_valid                       = true,
                 rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                 rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
};
 
template <typename T>
class fixed_point_scalar : public scalar {
  static_assert(is_fixed_point<T>(), "Unexpected non-fixed_point type.");
 
 public:
  using rep_type   = typename T::rep;  
  using value_type = T;                
 
  fixed_point_scalar()           = delete;
  ~fixed_point_scalar() override = default;
 
  fixed_point_scalar(fixed_point_scalar&& other) = default;
 
  fixed_point_scalar& operator=(fixed_point_scalar const& other) = delete;
  fixed_point_scalar& operator=(fixed_point_scalar&& other)      = delete;
 
  fixed_point_scalar(fixed_point_scalar const& other,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  fixed_point_scalar(rep_type value,
                     numeric::scale_type scale,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  fixed_point_scalar(rep_type value,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  fixed_point_scalar(T value,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  fixed_point_scalar(rmm::device_scalar<rep_type>&& data,
                     numeric::scale_type scale,
                     bool is_valid                       = true,
                     rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                     rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  rep_type value(rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  T fixed_point_value(rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  explicit operator value_type() const;
 
  rep_type* data();
 
  rep_type const* data() const;
 
 protected:
  rmm::device_scalar<rep_type> _data;  
};
 
class string_scalar : public scalar {
 public:
  using value_type = cudf::string_view;  
 
  string_scalar()           = delete;
  ~string_scalar() override = default;
 
  string_scalar(string_scalar&& other) = default;
 
  // string_scalar(string_scalar const& other) = delete;
  string_scalar& operator=(string_scalar const& other) = delete;
  string_scalar& operator=(string_scalar&& other)      = delete;
 
  string_scalar(string_scalar const& other,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  string_scalar(std::string const& string,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  string_scalar(value_type const& source,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  string_scalar(rmm::device_scalar<value_type>& data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  string_scalar(rmm::device_buffer&& data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  explicit operator std::string() const;
 
  [[nodiscard]] std::string to_string(
    rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  [[nodiscard]] value_type value(rmm::cuda_stream_view stream = cudf::get_default_stream()) const;
 
  [[nodiscard]] size_type size() const;
 
  [[nodiscard]] char const* data() const;
 
 protected:
  rmm::device_buffer _data{};  
};
 
template <typename T>
class chrono_scalar : public detail::fixed_width_scalar<T> {
  static_assert(is_chrono<T>(), "Unexpected non-chrono type");
 
 public:
  chrono_scalar()  = delete;
  ~chrono_scalar() = default;
 
  chrono_scalar(chrono_scalar&& other) = default;
 
  chrono_scalar& operator=(chrono_scalar const& other) = delete;
  chrono_scalar& operator=(chrono_scalar&& other)      = delete;
 
  chrono_scalar(chrono_scalar const& other,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  chrono_scalar(T value,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  chrono_scalar(rmm::device_scalar<T>&& data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
};
 
template <typename T>
class timestamp_scalar : public chrono_scalar<T> {
 public:
  static_assert(is_timestamp<T>(), "Unexpected non-timestamp type");
  using chrono_scalar<T>::chrono_scalar;
  using rep_type = typename T::rep;  
 
  timestamp_scalar() = delete;
 
  timestamp_scalar(timestamp_scalar&& other) = default;
 
  timestamp_scalar(timestamp_scalar const& other,
                   rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  template <typename Duration2>
  timestamp_scalar(Duration2 const& value,
                   bool is_valid,
                   rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  rep_type ticks_since_epoch();
};
 
template <typename T>
class duration_scalar : public chrono_scalar<T> {
 public:
  static_assert(is_duration<T>(), "Unexpected non-duration type");
  using chrono_scalar<T>::chrono_scalar;
  using rep_type = typename T::rep;  
 
  duration_scalar() = delete;
 
  duration_scalar(duration_scalar&& other) = default;
 
  duration_scalar(duration_scalar const& other,
                  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  duration_scalar(rep_type value,
                  bool is_valid,
                  rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  rep_type count();
};
 
class list_scalar : public scalar {
 public:
  list_scalar()           = delete;
  ~list_scalar() override = default;
 
  list_scalar(list_scalar&& other) = default;
 
  list_scalar& operator=(list_scalar const& other) = delete;
  list_scalar& operator=(list_scalar&& other)      = delete;
 
  list_scalar(list_scalar const& other,
              rmm::cuda_stream_view stream        = cudf::get_default_stream(),
              rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  list_scalar(cudf::column_view const& data,
              bool is_valid                       = true,
              rmm::cuda_stream_view stream        = cudf::get_default_stream(),
              rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  list_scalar(cudf::column&& data,
              bool is_valid                       = true,
              rmm::cuda_stream_view stream        = cudf::get_default_stream(),
              rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  [[nodiscard]] column_view view() const;
 
 private:
  cudf::column _data;
};
 
class struct_scalar : public scalar {
 public:
  struct_scalar()           = delete;
  ~struct_scalar() override = default;
 
  struct_scalar(struct_scalar&& other)                 = default;
  struct_scalar& operator=(struct_scalar const& other) = delete;
  struct_scalar& operator=(struct_scalar&& other)      = delete;
 
  struct_scalar(struct_scalar const& other,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  struct_scalar(table_view const& data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  struct_scalar(host_span<column_view const> data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  struct_scalar(table&& data,
                bool is_valid                       = true,
                rmm::cuda_stream_view stream        = cudf::get_default_stream(),
                rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
  [[nodiscard]] table_view view() const;
 
 private:
  table _data;
 
  void assert_valid_size();
 
  static table init_data(table&& data,
                         bool is_valid,
                         rmm::cuda_stream_view stream,
                         rmm::mr::device_memory_resource* mr);
};
  // end of group
}  // namespace cudf