Add partition field/partition spec/transform

Author: gty404

src/iceberg/CMakeLists.txt

@@ -22,7 +22,10 @@ set(ICEBERG_SOURCES
     demo.cc
     schema.cc
     schema_field.cc
-    type.cc)
+    type.cc
+    transform.cc
+    partition_field.cc
+    partition_spec.cc)
 
 set(ICEBERG_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_SHARED_BUILD_INTERFACE_LIBS)

src/iceberg/error.h

@@ -32,6 +32,7 @@ enum class ErrorKind {
   kAlreadyExists,
   kNoSuchTable,
   kCommitStateUnknown,
+  kNotSupported,
 };
 
 /// \brief Error with a kind and a message.

src/iceberg/exception.h

@@ -38,4 +38,11 @@ class ICEBERG_EXPORT IcebergError : public std::runtime_error {
   explicit IcebergError(const std::string& what) : std::runtime_error(what) {}
 };
 
+#define ICEBERG_CHECK_FMT(condition, ...)                    \
+  do {                                                       \
+    if (!(condition)) [[unlikely]] {                         \
+      throw iceberg::IcebergError(std::format(__VA_ARGS__)); \
+    }                                                        \
+  } while (0)
+
 }  // namespace iceberg

src/iceberg/partition_field.cc

@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "iceberg/partition_field.h"
+
+#include <format>
+
+#include "iceberg/transform.h"
+#include "iceberg/type.h"
+#include "iceberg/util/formatter.h"
+
+namespace iceberg {
+
+PartitionField::PartitionField(int32_t source_field_id, int32_t field_id,
+                               std::string name, TransformType transformType)
+    : source_field_id_(source_field_id),
+      field_id_(field_id),
+      name_(std::move(name)),
+      transform_type_(transformType) {}
+
+int32_t PartitionField::source_field_id() const { return source_field_id_; }
+
+int32_t PartitionField::field_id() const { return field_id_; }
+
+std::string_view PartitionField::name() const { return name_; }
+
+TransformType PartitionField::transform_type() const { return transform_type_; }
+
+std::string PartitionField::ToString() const {
+  return std::format("{} ({} {}({}))", name_, field_id_,
+                     iceberg::ToString(transform_type_), source_field_id_);
+}
+
+bool PartitionField::Equals(const PartitionField& other) const {
+  return source_field_id_ == other.source_field_id_ && field_id_ == other.field_id_ &&
+         name_ == other.name_ && transform_type_ == other.transform_type_;
+}
+
+}  // namespace iceberg

src/iceberg/partition_field.h

@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+
+/// \file iceberg/partition_field.h
+/// A partition field in a partition spec
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <string_view>
+
+#include "iceberg/iceberg_export.h"
+#include "iceberg/type_fwd.h"
+#include "iceberg/util/formattable.h"
+
+namespace iceberg {
+
+/// \brief a field with its transform.
+class ICEBERG_EXPORT PartitionField : public util::Formattable {
+ public:
+  /// \brief Construct a field.
+  /// \param[in] source_id The source field ID.
+  /// \param[in] field_id The partition field ID.
+  /// \param[in] name The partition field name.
+  /// \param[in] transformType The transform type.
+  PartitionField(int32_t source_id, int32_t field_id, std::string name, TransformType transformType);
+
+  /// \brief Get the source field ID.
+  [[nodiscard]] int32_t source_field_id() const;
+
+  /// \brief Get the partition field ID.
+  [[nodiscard]] int32_t field_id() const;
+
+  /// \brief Get the partition field name.
+  [[nodiscard]] std::string_view name() const;
+
+  /// \brief Get the transform type.
+  [[nodiscard]] TransformType transform_type() const;
+
+  [[nodiscard]] std::string ToString() const override;
+
+  friend bool operator==(const PartitionField& lhs, const PartitionField& rhs) {
+    return lhs.Equals(rhs);
+  }
+
+  friend bool operator!=(const PartitionField& lhs, const PartitionField& rhs) {
+    return !(lhs == rhs);
+  }
+
+ private:
+  /// \brief Compare two fields for equality.
+  [[nodiscard]] bool Equals(const PartitionField& other) const;
+
+  int32_t source_field_id_;
+  int32_t field_id_;
+  std::string name_;
+  TransformType transform_type_;
+};
+
+}  // namespace iceberg

src/iceberg/partition_spec.cc

@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "iceberg/partition_spec.h"
+
+#include <format>
+
+#include "iceberg/exception.h"
+#include "iceberg/type.h"
+#include "iceberg/util/formatter.h"
+
+namespace iceberg {
+
+PartitionSpec::PartitionSpec(int32_t spec_id, std::vector<PartitionField> fields)
+    : spec_id_(spec_id), fields_(std::move(fields)) {
+  size_t index = 0;
+  for (const auto& field : fields_) {
+    auto [it, inserted] = field_id_to_index_.try_emplace(field.field_id(), index);
+    ICEBERG_CHECK_FMT(inserted,
+                      "PartitionSpec: duplicate field ID {} (field indices {} and {})",
+                      field.field_id(), it->second, index);
+    ++index;
+  }
+}
+
+int32_t PartitionSpec::spec_id() const { return spec_id_; }
+
+std::span<const PartitionField> PartitionSpec::fields() const { return fields_; }
+
+std::optional<std::reference_wrapper<const PartitionField>> PartitionSpec::GetFieldById(
+    int32_t field_id) const {
+  if (auto it = field_id_to_index_.find(field_id); it != field_id_to_index_.end()) {
+    return fields_[it->second];
+  }
+  return std::nullopt;
+}
+
+std::optional<std::reference_wrapper<const PartitionField>>
+PartitionSpec::GetFieldByIndex(int32_t index) const {
+  if (index >= 0 && index < static_cast<int>(fields_.size())) {
+    return fields_[index];
+  }
+  return std::nullopt;
+}
+
+std::optional<std::reference_wrapper<const PartitionField>> PartitionSpec::GetFieldByName(
+    std::string_view name) const {
+  auto findField = [&name](auto& field) { return field.name() == name; };
+  if (auto it = std::ranges::find_if(fields_, findField); it != fields_.end()) {
+    return *it;
+  }
+  return std::nullopt;
+}
+
+std::string PartitionSpec::ToString() const {
+  std::string repr = "partition_spec(<";
+  for (const auto& field : fields_) {
+    std::format_to(std::back_inserter(repr), "  {}\n", field);
+  }
+  repr += ">";
+  return repr;
+}
+
+bool PartitionSpec::Equals(const PartitionSpec& other) const {
+  return spec_id_ == other.spec_id_ && fields_ == other.fields_;
+}
+
+}  // namespace iceberg

src/iceberg/partition_spec.h

@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+
+/// \file iceberg/partition_spec.h
+/// Partition specs for Iceberg tables.
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <span>
+
+#include "iceberg/iceberg_export.h"
+#include "iceberg/partition_field.h"
+
+namespace iceberg {
+
+/// \brief A partition spec for a Table.
+///
+/// A partition spec is a list of partition fields, along with a unique integer ID.  A
+/// Table may have different partition specs over its lifetime due to partition spec
+/// evolution.
+class ICEBERG_EXPORT PartitionSpec {
+ public:
+  virtual ~PartitionSpec() = default;
+  PartitionSpec(int32_t spec_id, std::vector<PartitionField> fields);
+  /// \brief Get the spec ID.
+  [[nodiscard]] int32_t spec_id() const;
+  /// \brief Get a view of the partition fields.
+  [[nodiscard]] virtual std::span<const PartitionField> fields() const;
+  /// \brief Get a field by field ID.
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const PartitionField>>
+  GetFieldById(int32_t field_id) const;
+  /// \brief Get a field by index.
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const PartitionField>>
+  GetFieldByIndex(int32_t index) const;
+  /// \brief Get a field by name (case-sensitive).
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const PartitionField>>
+  GetFieldByName(std::string_view name) const;
+
+  [[nodiscard]] std::string ToString() const;
+
+  friend bool operator==(const PartitionSpec& lhs, const PartitionSpec& rhs) { return lhs.Equals(rhs); }
+
+  friend bool operator!=(const PartitionSpec& lhs, const PartitionSpec& rhs) { return !(lhs == rhs); }
+
+ private:
+  /// \brief Compare two partition specs for equality.
+  [[nodiscard]] bool Equals(const PartitionSpec& other) const;
+
+  const int32_t spec_id_;
+  std::vector<PartitionField> fields_;
+  std::unordered_map<int32_t, size_t> field_id_to_index_;
+};
+
+}  // namespace iceberg

src/iceberg/transform.cc

@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "iceberg/transform.h"
+
+#include <format>
+
+namespace iceberg {
+
+TransformFunction::TransformFunction(TransformType type) : transform_type_(type) {}
+
+TransformType TransformFunction::transform_type() const { return transform_type_; }
+
+std::string TransformFunction::ToString() const {
+  return std::format("{}", iceberg::ToString(transform_type_));
+}
+
+}  // namespace iceberg