feat(type): add insensitive way to find schemafield & test

nullccxsy · nullccxsy · commit 06adc3f568f9 · 2025-08-15T18:55:51.000+08:00
diff --git a/src/iceberg/type.cc b/src/iceberg/type.cc
@@ -19,9 +19,16 @@
 
 #include "iceberg/type.h"
 
+#include <algorithm>
+#include <cctype>
 #include <format>
+#include <functional>
 #include <iterator>
 #include <memory>
+#include <optional>
+#include <ranges>
+#include <string_view>
+#include <iceberg/schema_field.h>
 
 #include "iceberg/exception.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
@@ -70,12 +77,19 @@ std::optional<std::reference_wrapper<const SchemaField>> StructType::GetFieldByN
     std::string_view name) const {
   // N.B. duplicate names are not permitted (looking at the Java
   // implementation) so there is nothing in particular we need to do here
-  for (const auto& field : fields_) {
-    if (field.name() == name) {
-      return field;
-    }
-  }
-  return std::nullopt;
+  InitNameToIdMap();
+  auto it = field_name_to_index_.find(std::string(name));
+  if (it == field_name_to_index_.end()) return std::nullopt;
+  return fields_[it->second];
+}
+std::optional<std::reference_wrapper<const SchemaField>> StructType::GetFieldByNameCaseInsensitive(
+  std::string_view name) const {
+  InitNameToIdMapCaseInsensitive();
+  std::string lower_name(name);
+  std::ranges::transform(lower_name, lower_name.begin(), ::tolower);
+  auto it = caseinsensitive_field_name_to_index_.find(lower_name);
+  if (it == caseinsensitive_field_name_to_index_.end()) return std::nullopt;
+  return fields_[it->second];
 }
 bool StructType::Equals(const Type& other) const {
   if (other.type_id() != TypeId::kStruct) {
@@ -84,6 +98,26 @@ bool StructType::Equals(const Type& other) const {
   const auto& struct_ = static_cast<const StructType&>(other);
   return fields_ == struct_.fields_;
 }
+void StructType::InitNameToIdMap() const {
+  if (!field_name_to_index_.empty()) {
+    return;
+  }
+  
+  for (int i = 0; i < fields_.size(); i++) {
+    field_name_to_index_[std::string(fields_[i].name())]  = i;
+  }
+}
+void StructType::InitNameToIdMapCaseInsensitive() const {
+  if (!caseinsensitive_field_name_to_index_.empty()) {
+    return;
+  }
+  
+  for (int i = 0; i < fields_.size(); i++) {
+    std::string lowercase_name(fields_[i].name());
+    std::ranges::transform(lowercase_name, lowercase_name.begin(), ::tolower);
+    caseinsensitive_field_name_to_index_[lowercase_name] = i;
+  }
+}
 
 ListType::ListType(SchemaField element) : element_(std::move(element)) {
   if (element_.name() != kElementName) {
@@ -126,6 +160,15 @@ std::optional<std::reference_wrapper<const SchemaField>> ListType::GetFieldByNam
   }
   return std::nullopt;
 }
+std::optional<std::reference_wrapper<const SchemaField>> ListType::GetFieldByNameCaseInsensitive(
+    std::string_view name) const {
+  auto lower_name_view = name | std::views::transform(::tolower);
+  auto lower_field_name = element_.name() | std::views::transform(::tolower);
+  if (std::ranges::equal(lower_field_name, lower_name_view)) {
+    return std::cref(element_);
+  } 
+  return std::nullopt;
+}
 bool ListType::Equals(const Type& other) const {
   if (other.type_id() != TypeId::kList) {
     return false;
@@ -186,6 +229,18 @@ std::optional<std::reference_wrapper<const SchemaField>> MapType::GetFieldByName
   }
   return std::nullopt;
 }
+std::optional<std::reference_wrapper<const SchemaField>> MapType::GetFieldByNameCaseInsensitive(
+    std::string_view name) const {
+  auto lower_name_view  = name | std::views::transform(::tolower);
+  auto lower_key_view = kKeyName | std::views::transform(tolower);
+  auto lower_value_view = kValueName | std::views::transform(tolower);
+  if (std::ranges::equal(lower_key_view, lower_name_view)) {
+    return key();
+  } else if (std::ranges::equal(lower_value_view, lower_name_view)) {
+    return value();
+  }
+  return std::nullopt;
+}
 bool MapType::Equals(const Type& other) const {
   if (other.type_id() != TypeId::kMap) {
     return false;
diff --git a/src/iceberg/type.h b/src/iceberg/type.h
@@ -25,6 +25,7 @@
 
 #include <array>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <span>
@@ -81,17 +82,22 @@ class ICEBERG_EXPORT NestedType : public Type {
   [[nodiscard]] virtual std::optional<std::reference_wrapper<const SchemaField>>
   GetFieldById(int32_t field_id) const = 0;
   /// \brief Get a field by index.
+
   ///
   /// \note This is O(1) complexity.
   [[nodiscard]] virtual std::optional<std::reference_wrapper<const SchemaField>>
   GetFieldByIndex(int32_t index) const = 0;
   /// \brief Get a field by name (case-sensitive).  Behavior is undefined if
   ///   the field name is not unique; prefer GetFieldById or GetFieldByIndex
   ///   when possible.
+
   ///
-  /// \note This is currently O(n) complexity.
+  /// \note This is currently O(1) complexity.
   [[nodiscard]] virtual std::optional<std::reference_wrapper<const SchemaField>>
   GetFieldByName(std::string_view name) const = 0;
+
+  [[nodiscard]] virtual std::optional<std::reference_wrapper<const SchemaField>>
+  GetFieldByNameCaseInsensitive(std::string_view name) const = 0;
 };
 
 /// \defgroup type-nested Nested Types
@@ -115,12 +121,18 @@ class ICEBERG_EXPORT StructType : public NestedType {
       int32_t index) const override;
   std::optional<std::reference_wrapper<const SchemaField>> GetFieldByName(
       std::string_view name) const override;
+  std::optional<std::reference_wrapper<const SchemaField>> GetFieldByNameCaseInsensitive(
+      std::string_view name) const override;
+  void InitNameToIdMap() const;
+  void InitNameToIdMapCaseInsensitive() const;
 
  protected:
   bool Equals(const Type& other) const override;
 
   std::vector<SchemaField> fields_;
   std::unordered_map<int32_t, size_t> field_id_to_index_;
+  mutable std::unordered_map<std::string, size_t> field_name_to_index_;
+  mutable std::unordered_map<std::string, size_t> caseinsensitive_field_name_to_index_;
 };
 
 /// \brief A data type representing a list of values.
@@ -146,6 +158,8 @@ class ICEBERG_EXPORT ListType : public NestedType {
       int32_t index) const override;
   std::optional<std::reference_wrapper<const SchemaField>> GetFieldByName(
       std::string_view name) const override;
+  std::optional<std::reference_wrapper<const SchemaField>> GetFieldByNameCaseInsensitive(
+      std::string_view name) const override;
 
  protected:
   bool Equals(const Type& other) const override;
@@ -178,7 +192,9 @@ class ICEBERG_EXPORT MapType : public NestedType {
       int32_t index) const override;
   std::optional<std::reference_wrapper<const SchemaField>> GetFieldByName(
       std::string_view name) const override;
-
+  std::optional<std::reference_wrapper<const SchemaField>> GetFieldByNameCaseInsensitive(
+      std::string_view name) const override;
+      
  protected:
   bool Equals(const Type& other) const override;
 
diff --git a/test/type_test.cc b/test/type_test.cc
@@ -21,11 +21,13 @@
 
 #include <format>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "gmock/gmock.h"
 #include "iceberg/exception.h"
 #include "iceberg/util/formatter.h"  // IWYU pragma: keep
 
@@ -318,11 +320,13 @@ TEST(TypeTest, List) {
     ASSERT_THAT(list.GetFieldById(5), ::testing::Optional(field));
     ASSERT_THAT(list.GetFieldByIndex(0), ::testing::Optional(field));
     ASSERT_THAT(list.GetFieldByName("element"), ::testing::Optional(field));
+    ASSERT_THAT(list.GetFieldByNameCaseInsensitive("ELEMENT"), ::testing::Optional(field));
 
     ASSERT_EQ(std::nullopt, list.GetFieldById(0));
     ASSERT_EQ(std::nullopt, list.GetFieldByIndex(1));
     ASSERT_EQ(std::nullopt, list.GetFieldByIndex(-1));
     ASSERT_EQ(std::nullopt, list.GetFieldByName("foo"));
+    ASSERT_EQ(std::nullopt, list.GetFieldByNameCaseInsensitive("FOO"));
   }
   ASSERT_THAT(
       []() {
@@ -348,11 +352,16 @@ TEST(TypeTest, Map) {
     ASSERT_THAT(map.GetFieldByIndex(1), ::testing::Optional(value));
     ASSERT_THAT(map.GetFieldByName("key"), ::testing::Optional(key));
     ASSERT_THAT(map.GetFieldByName("value"), ::testing::Optional(value));
+    ASSERT_THAT(map.GetFieldByNameCaseInsensitive("KEY"), ::testing::Optional(key));
+    ASSERT_THAT(map.GetFieldByNameCaseInsensitive("VALUE"), ::testing::Optional(value));
+
 
     ASSERT_EQ(std::nullopt, map.GetFieldById(0));
     ASSERT_EQ(std::nullopt, map.GetFieldByIndex(2));
     ASSERT_EQ(std::nullopt, map.GetFieldByIndex(-1));
     ASSERT_EQ(std::nullopt, map.GetFieldByName("element"));
+    ASSERT_EQ(std::nullopt, map.GetFieldByName(""));
+    ASSERT_EQ(std::nullopt, map.GetFieldByNameCaseInsensitive(""));
   }
   ASSERT_THAT(
       []() {
@@ -387,11 +396,14 @@ TEST(TypeTest, Struct) {
     ASSERT_THAT(struct_.GetFieldByIndex(1), ::testing::Optional(field2));
     ASSERT_THAT(struct_.GetFieldByName("foo"), ::testing::Optional(field1));
     ASSERT_THAT(struct_.GetFieldByName("bar"), ::testing::Optional(field2));
+    ASSERT_THAT(struct_.GetFieldByNameCaseInsensitive("FOO"), ::testing::Optional(field1));
+    ASSERT_THAT(struct_.GetFieldByNameCaseInsensitive("Bar"), ::testing::Optional(field2));
 
     ASSERT_EQ(std::nullopt, struct_.GetFieldById(0));
     ASSERT_EQ(std::nullopt, struct_.GetFieldByIndex(2));
     ASSERT_EQ(std::nullopt, struct_.GetFieldByIndex(-1));
     ASSERT_EQ(std::nullopt, struct_.GetFieldByName("element"));
+    ASSERT_EQ(std::nullopt, struct_.GetFieldByNameCaseInsensitive("element"));
   }
   ASSERT_THAT(
       []() {
