change sort_direction to direction according to the spec

Signed-off-by: Junwang Zhao <[email protected]>

Author: zhjwpku

src/iceberg/sort_field.cc

@@ -54,10 +54,10 @@ constexpr std::string_view ToString(NullOrder null_order) {
 }  // namespace
 
 SortField::SortField(int32_t source_id, std::shared_ptr<TransformFunction> transform,
-                     SortDirection sort_direction, NullOrder null_order)
+                     SortDirection direction, NullOrder null_order)
     : source_id_(source_id),
       transform_(std::move(transform)),
-      sort_direction_(sort_direction),
+      direction_(direction),
       null_order_(null_order) {}
 
 int32_t SortField::source_id() const { return source_id_; }
@@ -66,20 +66,19 @@ std::shared_ptr<TransformFunction> const& SortField::transform() const {
   return transform_;
 }
 
-SortDirection SortField::sort_direction() const { return sort_direction_; }
+SortDirection SortField::direction() const { return direction_; }
 
 NullOrder SortField::null_order() const { return null_order_; }
 
 std::string SortField::ToString() const {
   return std::format(
-      "SortField(source_id={}, transform={}, sort_direction={}, null_order={})",
-      source_id_, *transform_, iceberg::ToString(sort_direction_),
-      iceberg::ToString(null_order_));
+      "sort_field(source_id={}, transform={}, direction={}, null_order={})", source_id_,
+      *transform_, iceberg::ToString(direction_), iceberg::ToString(null_order_));
 }
 
 bool SortField::Equals(const SortField& other) const {
   return source_id_ == other.source_id_ && *transform_ == *other.transform_ &&
-         sort_direction_ == other.sort_direction_ && null_order_ == other.null_order_;
+         direction_ == other.direction_ && null_order_ == other.null_order_;
 }
 
 }  // namespace iceberg

src/iceberg/sort_field.h

@@ -55,10 +55,10 @@ class ICEBERG_EXPORT SortField : public util::Formattable {
   /// \brief Construct a field.
   /// \param[in] source_id The source field ID.
   /// \param[in] transform The transform function.
-  /// \param[in] sort_direction The sort direction.
+  /// \param[in] direction The sort direction.
   /// \param[in] null_order The null order.
   SortField(int32_t source_id, std::shared_ptr<TransformFunction> transform,
-            SortDirection sort_direction, NullOrder null_order);
+            SortDirection direction, NullOrder null_order);
 
   /// \brief Get the source field ID.
   int32_t source_id() const;
@@ -67,7 +67,7 @@ class ICEBERG_EXPORT SortField : public util::Formattable {
   const std::shared_ptr<TransformFunction>& transform() const;
 
   /// \brief Get the sort direction.
-  SortDirection sort_direction() const;
+  SortDirection direction() const;
 
   /// \brief Get the null order.
   NullOrder null_order() const;
@@ -88,7 +88,7 @@ class ICEBERG_EXPORT SortField : public util::Formattable {
 
   int32_t source_id_;
   std::shared_ptr<TransformFunction> transform_;
-  SortDirection sort_direction_;
+  SortDirection direction_;
   NullOrder null_order_;
 };
 

test/sort_field_test.cc

@@ -46,14 +46,14 @@ TEST(SortFieldTest, Basics) {
     SortField field(1, transform, SortDirection::kAscending, NullOrder::kFirst);
     EXPECT_EQ(1, field.source_id());
     EXPECT_EQ(*transform, *field.transform());
-    EXPECT_EQ(SortDirection::kAscending, field.sort_direction());
+    EXPECT_EQ(SortDirection::kAscending, field.direction());
     EXPECT_EQ(NullOrder::kFirst, field.null_order());
     EXPECT_EQ(
-        "SortField(source_id=1, transform=identity, sort_direction=asc, "
+        "sort_field(source_id=1, transform=identity, direction=asc, "
         "null_order=nulls-first)",
         field.ToString());
     EXPECT_EQ(
-        "SortField(source_id=1, transform=identity, sort_direction=asc, "
+        "sort_field(source_id=1, transform=identity, direction=asc, "
         "null_order=nulls-first)",
         std::format("{}", field));
   }

test/sort_order_test.cc

@@ -60,10 +60,11 @@ TEST(SortOrderTest, Basics) {
     ASSERT_EQ(st_field1, fields[0]);
     ASSERT_EQ(st_field2, fields[1]);
     auto sort_order_str =
-        "sort_order[order_id<100>,\n  SortField(source_id=5, transform=identity, "
-        "sort_direction=asc, null_order=nulls-first)\n  SortField(source_id=7, "
-        "transform=identity, "
-        "sort_direction=desc, null_order=nulls-first)\n]";
+        "sort_order[order_id<100>,\n"
+        "  sort_field(source_id=5, transform=identity, direction=asc, "
+        "null_order=nulls-first)\n"
+        "  sort_field(source_id=7, transform=identity, direction=desc, "
+        "null_order=nulls-first)\n]";
     EXPECT_EQ(sort_order_str, sort_order.ToString());
     EXPECT_EQ(sort_order_str, std::format("{}", sort_order));
   }