Nested struct binop comparison

cpp/include/cudf/detail/structs/utilities.hpp

@@ -245,6 +245,20 @@ std::tuple<cudf::table_view, std::vector<rmm::device_buffer>> superimpose_parent
   table_view const& table,
   rmm::cuda_stream_view stream        = rmm::cuda_stream_default,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
+
+/**
+ * @brief Checks if a column or any of its children is a struct column with structs that are null.
+ *
+ * This function searches for structs that are null -- differentiating between structs that are null
+ * and structs containing null values. Null structs add a column to the result of the flatten column
+ * utility and necessitates column_nullability::FORCE when flattening the column for comparison
+ * operations.
+ *
+ * @param col Column to check for null structs
+ * @return A boolean indicating if the column is or contains a struct column that contains a null
+ * struct.
+ */
+bool contains_null_structs(column_view const& col);
 }  // namespace detail
 }  // namespace structs
 }  // namespace cudf

cpp/include/cudf/utilities/traits.hpp

@@ -673,6 +673,37 @@ constexpr inline bool is_nested(data_type type)
   return cudf::type_dispatcher(type, is_nested_impl{});
 }
 
+/**
+ * @brief Indicates whether `T` is a struct type.
+ *
+ * @param T The type to verify
+ * @return A boolean indicating if T is a struct type
+ */
+template <typename T>
+constexpr inline bool is_struct()
+{
+  return std::is_same_v<T, cudf::struct_view>;
+}
+
+struct is_struct_impl {
+  template <typename T>
+  constexpr bool operator()()
+  {
+    return is_struct<T>();
+  }
+};
+
+/**
+ * @brief Indicates whether `type` is a struct type.
+ *
+ * @param type The `data_type` to verify
+ * @return A boolean indicating if `type` is a struct type
+ */
+constexpr inline bool is_struct(data_type type)
+{
+  return cudf::type_dispatcher(type, is_struct_impl{});
+}
+
 template <typename FromType>
 struct is_bit_castable_to_impl {
   template <typename ToType, typename std::enable_if_t<is_compound<ToType>()>* = nullptr>

cpp/src/binaryop/compiled/ATan2.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::ATan2>(mutable_column_device_view&,
-                                          column_device_view const&,
-                                          column_device_view const&,
+template void apply_binary_op<ops::ATan2>(mutable_column_view&,
+                                          column_view const&,
+                                          column_view const&,
                                           bool is_lhs_scalar,
                                           bool is_rhs_scalar,
                                           rmm::cuda_stream_view);

cpp/src/binaryop/compiled/Add.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Add>(mutable_column_device_view&,
-                                        column_device_view const&,
-                                        column_device_view const&,
+template void apply_binary_op<ops::Add>(mutable_column_view&,
+                                        column_view const&,
+                                        column_view const&,
                                         bool is_lhs_scalar,
                                         bool is_rhs_scalar,
                                         rmm::cuda_stream_view);

cpp/src/binaryop/compiled/BitwiseAnd.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::BitwiseAnd>(mutable_column_device_view&,
-                                               column_device_view const&,
-                                               column_device_view const&,
+template void apply_binary_op<ops::BitwiseAnd>(mutable_column_view&,
+                                               column_view const&,
+                                               column_view const&,
                                                bool is_lhs_scalar,
                                                bool is_rhs_scalar,
                                                rmm::cuda_stream_view);

cpp/src/binaryop/compiled/BitwiseOr.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::BitwiseOr>(mutable_column_device_view&,
-                                              column_device_view const&,
-                                              column_device_view const&,
+template void apply_binary_op<ops::BitwiseOr>(mutable_column_view&,
+                                              column_view const&,
+                                              column_view const&,
                                               bool is_lhs_scalar,
                                               bool is_rhs_scalar,
                                               rmm::cuda_stream_view);

cpp/src/binaryop/compiled/BitwiseXor.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::BitwiseXor>(mutable_column_device_view&,
-                                               column_device_view const&,
-                                               column_device_view const&,
+template void apply_binary_op<ops::BitwiseXor>(mutable_column_view&,
+                                               column_view const&,
+                                               column_view const&,
                                                bool is_lhs_scalar,
                                                bool is_rhs_scalar,
                                                rmm::cuda_stream_view);

cpp/src/binaryop/compiled/Div.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Div>(mutable_column_device_view&,
-                                        column_device_view const&,
-                                        column_device_view const&,
+template void apply_binary_op<ops::Div>(mutable_column_view&,
+                                        column_view const&,
+                                        column_view const&,
                                         bool is_lhs_scalar,
                                         bool is_rhs_scalar,
                                         rmm::cuda_stream_view);

cpp/src/binaryop/compiled/FloorDiv.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::FloorDiv>(mutable_column_device_view&,
-                                             column_device_view const&,
-                                             column_device_view const&,
+template void apply_binary_op<ops::FloorDiv>(mutable_column_view&,
+                                             column_view const&,
+                                             column_view const&,
                                              bool is_lhs_scalar,
                                              bool is_rhs_scalar,
                                              rmm::cuda_stream_view);

cpp/src/binaryop/compiled/Greater.cu

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
+#include <binaryop/compiled/struct_binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Greater>(mutable_column_device_view&,
-                                            column_device_view const&,
-                                            column_device_view const&,
-                                            bool is_lhs_scalar,
-                                            bool is_rhs_scalar,
-                                            rmm::cuda_stream_view);
+template <>
+void apply_binary_op<ops::Greater>(mutable_column_view& out,
+                                   column_view const& lhs,
+                                   column_view const& rhs,
+                                   bool is_lhs_scalar,
+                                   bool is_rhs_scalar,
+                                   rmm::cuda_stream_view stream)
+{
+  detail::apply_binary_op_impl<ops::Greater>(
+    out, lhs, rhs, is_lhs_scalar, is_rhs_scalar, order::DESCENDING, false, stream);
 }
+}  // namespace cudf::binops::compiled

cpp/src/binaryop/compiled/GreaterEqual.cu

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
+#include <binaryop/compiled/struct_binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::GreaterEqual>(mutable_column_device_view&,
-                                                 column_device_view const&,
-                                                 column_device_view const&,
-                                                 bool is_lhs_scalar,
-                                                 bool is_rhs_scalar,
-                                                 rmm::cuda_stream_view);
+template <>
+void apply_binary_op<ops::GreaterEqual>(mutable_column_view& out,
+                                        column_view const& lhs,
+                                        column_view const& rhs,
+                                        bool is_lhs_scalar,
+                                        bool is_rhs_scalar,
+                                        rmm::cuda_stream_view stream)
+{
+  detail::apply_binary_op_impl<ops::GreaterEqual>(
+    out, lhs, rhs, is_lhs_scalar, is_rhs_scalar, order::ASCENDING, true, stream);
 }
+}  // namespace cudf::binops::compiled

cpp/src/binaryop/compiled/Less.cu

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
+#include <binaryop/compiled/struct_binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Less>(mutable_column_device_view&,
-                                         column_device_view const&,
-                                         column_device_view const&,
-                                         bool is_lhs_scalar,
-                                         bool is_rhs_scalar,
-                                         rmm::cuda_stream_view);
+template <>
+void apply_binary_op<ops::Less>(mutable_column_view& out,
+                                column_view const& lhs,
+                                column_view const& rhs,
+                                bool is_lhs_scalar,
+                                bool is_rhs_scalar,
+                                rmm::cuda_stream_view stream)
+{
+  detail::apply_binary_op_impl<ops::Less>(
+    out, lhs, rhs, is_lhs_scalar, is_rhs_scalar, order::ASCENDING, false, stream);
 }
+}  // namespace cudf::binops::compiled

cpp/src/binaryop/compiled/LessEqual.cu

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
+#include <binaryop/compiled/struct_binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::LessEqual>(mutable_column_device_view&,
-                                              column_device_view const&,
-                                              column_device_view const&,
-                                              bool is_lhs_scalar,
-                                              bool is_rhs_scalar,
-                                              rmm::cuda_stream_view);
+template <>
+void apply_binary_op<ops::LessEqual>(mutable_column_view& out,
+                                     column_view const& lhs,
+                                     column_view const& rhs,
+                                     bool is_lhs_scalar,
+                                     bool is_rhs_scalar,
+                                     rmm::cuda_stream_view stream)
+{
+  detail::apply_binary_op_impl<ops::LessEqual>(
+    out, lhs, rhs, is_lhs_scalar, is_rhs_scalar, order::DESCENDING, true, stream);
 }
+}  // namespace cudf::binops::compiled

cpp/src/binaryop/compiled/LogBase.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::LogBase>(mutable_column_device_view&,
-                                            column_device_view const&,
-                                            column_device_view const&,
+template void apply_binary_op<ops::LogBase>(mutable_column_view&,
+                                            column_view const&,
+                                            column_view const&,
                                             bool is_lhs_scalar,
                                             bool is_rhs_scalar,
                                             rmm::cuda_stream_view);

cpp/src/binaryop/compiled/LogicalAnd.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::LogicalAnd>(mutable_column_device_view&,
-                                               column_device_view const&,
-                                               column_device_view const&,
+template void apply_binary_op<ops::LogicalAnd>(mutable_column_view&,
+                                               column_view const&,
+                                               column_view const&,
                                                bool is_lhs_scalar,
                                                bool is_rhs_scalar,
                                                rmm::cuda_stream_view);

cpp/src/binaryop/compiled/LogicalOr.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::LogicalOr>(mutable_column_device_view&,
-                                              column_device_view const&,
-                                              column_device_view const&,
+template void apply_binary_op<ops::LogicalOr>(mutable_column_view&,
+                                              column_view const&,
+                                              column_view const&,
                                               bool is_lhs_scalar,
                                               bool is_rhs_scalar,
                                               rmm::cuda_stream_view);

cpp/src/binaryop/compiled/Mod.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Mod>(mutable_column_device_view&,
-                                        column_device_view const&,
-                                        column_device_view const&,
+template void apply_binary_op<ops::Mod>(mutable_column_view&,
+                                        column_view const&,
+                                        column_view const&,
                                         bool is_lhs_scalar,
                                         bool is_rhs_scalar,
                                         rmm::cuda_stream_view);

cpp/src/binaryop/compiled/Mul.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::Mul>(mutable_column_device_view&,
-                                        column_device_view const&,
-                                        column_device_view const&,
+template void apply_binary_op<ops::Mul>(mutable_column_view&,
+                                        column_view const&,
+                                        column_view const&,
                                         bool is_lhs_scalar,
                                         bool is_rhs_scalar,
                                         rmm::cuda_stream_view);

cpp/src/binaryop/compiled/NullMax.cu

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-#include "binary_ops.cuh"
+#include <binaryop/compiled/binary_ops.cuh>
 
 namespace cudf::binops::compiled {
-template void apply_binary_op<ops::NullMax>(mutable_column_device_view&,
-                                            column_device_view const&,
-                                            column_device_view const&,
+template void apply_binary_op<ops::NullMax>(mutable_column_view&,
+                                            column_view const&,
+                                            column_view const&,
                                             bool is_lhs_scalar,
                                             bool is_rhs_scalar,
                                             rmm::cuda_stream_view);