fix comments

Author: lxy-9602

src/paimon/common/utils/binary_row_partition_computer_test.cpp

@@ -251,20 +251,27 @@ TEST(BinaryRowPartitionComputerTest, TestNullOrWhitespaceOnlyStr) {
         arrow::field("f0", arrow::utf8()),
         arrow::field("f1", arrow::utf8()),
         arrow::field("f2", arrow::utf8()),
+        arrow::field("f3", arrow::utf8()),
     };
 
     auto schema = arrow::schema(fields);
-    std::vector<std::string> partition_keys = {"f0", "f1", "f2"};
+    std::vector<std::string> partition_keys = {"f0", "f1", "f2", "f3"};
     ASSERT_OK_AND_ASSIGN(
         std::unique_ptr<BinaryRowPartitionComputer> computer,
         BinaryRowPartitionComputer::Create(partition_keys, schema, "__DEFAULT_PARTITION__",
                                            /*legacy_partition_name_enabled=*/true, pool));
 
-    ASSERT_OK_AND_ASSIGN(auto partition_key_values,
-                         computer->GeneratePartitionVector(BinaryRowGenerator::GenerateRow(
-                             {std::string(" "), std::string(""), std::string("ab ")}, pool.get())));
+    ASSERT_OK_AND_ASSIGN(
+        auto partition_key_values,
+        computer->GeneratePartitionVector(BinaryRowGenerator::GenerateRow(
+            {std::string(" "), std::string(""), std::string("ab "), std::string(u8"\u3000\u2000")},
+            pool.get())));
     std::vector<std::pair<std::string, std::string>> expected = {
-        {"f0", "__DEFAULT_PARTITION__"}, {"f1", "__DEFAULT_PARTITION__"}, {"f2", "ab "}};
+        {"f0", "__DEFAULT_PARTITION__"},
+        {"f1", "__DEFAULT_PARTITION__"},
+        {"f2", "ab "},
+        {"f3", "__DEFAULT_PARTITION__"},
+    };
     ASSERT_EQ(partition_key_values, expected);
 }
 

src/paimon/common/utils/string_utils.cpp

@@ -141,6 +141,10 @@ bool StringUtils::IsNullOrWhitespaceOnly(const std::string& str) {
     return IsBlank(str);
 }
 
+bool StringUtils::IsEmptyAfterTrim(std::string_view str) {
+    return std::all_of(str.begin(), str.end(), [](unsigned char c) { return IsTrimCharacter(c); });
+}
+
 void StringUtils::Trim(std::string* str) {
     auto first = std::find_if_not(str->begin(), str->end(),
                                   [](unsigned char c) { return IsTrimCharacter(c); });

src/paimon/common/utils/string_utils.h

@@ -103,6 +103,9 @@ class PAIMON_EXPORT StringUtils {
 
     static bool IsNullOrWhitespaceOnly(const std::string& str);
 
+    /// Returns true if Java String::trim would produce an empty string.
+    static bool IsEmptyAfterTrim(std::string_view str);
+
     static void Trim(std::string* str);
 
     static std::string ToLowerCase(const std::string& str);

src/paimon/common/utils/string_utils_test.cpp

@@ -225,6 +225,19 @@ TEST_F(StringUtilsTest, TestIsBlank) {
     ASSERT_FALSE(StringUtils::IsBlank(" user1 "));
     ASSERT_FALSE(StringUtils::IsBlank(u8"\u00a0"));
     ASSERT_FALSE(StringUtils::IsBlank(std::string("\xc0\x80", 2)));
+
+    // Non-breaking or otherwise excluded by Character.isWhitespace.
+    ASSERT_FALSE(StringUtils::IsBlank(u8"\u2007"));  // FIGURE SPACE
+    ASSERT_FALSE(StringUtils::IsBlank(u8"\u202f"));  // NARROW NO-BREAK SPACE
+    ASSERT_FALSE(StringUtils::IsBlank(u8"\u0085"));  // NEL
+    ASSERT_FALSE(StringUtils::IsBlank(u8"\u180e"));  // Not whitespace since Java 8
+}
+
+TEST_F(StringUtilsTest, TestIsEmptyAfterTrim) {
+    ASSERT_TRUE(StringUtils::IsEmptyAfterTrim(""));
+    ASSERT_TRUE(StringUtils::IsEmptyAfterTrim(" \t\x1c"));
+    ASSERT_FALSE(StringUtils::IsEmptyAfterTrim(" a "));
+    ASSERT_FALSE(StringUtils::IsEmptyAfterTrim(u8"\u3000"));
 }
 
 TEST_F(StringUtilsTest, TestToLowerCase) {

src/paimon/core/index/pk/primary_key_index_definitions.cpp

@@ -102,7 +102,10 @@ Result<std::map<std::string, std::string>> SortedIndexOptions(
     std::string option_key =
         fmt::format("{}{}.{}.index.options", kFieldScopedPrefix, column, option_family);
     auto iter = table_options.find(option_key);
-    if (iter == table_options.end() || StringUtils::IsNullOrWhitespaceOnly(iter->second)) {
+    if (iter == table_options.end()) {
+        return resolved;
+    }
+    if (StringUtils::IsEmptyAfterTrim(iter->second)) {
         return resolved;
     }
 
@@ -113,11 +116,13 @@ Result<std::map<std::string, std::string>> SortedIndexOptions(
             fmt::format("{} must be a JSON object of option key-value pairs.", option_key));
     }
     for (auto member = document.MemberBegin(); member != document.MemberEnd(); ++member) {
-        if (!member->name.IsString() ||
-            StringUtils::IsNullOrWhitespaceOnly(member->name.GetString())) {
+        if (!member->name.IsString()) {
             return Status::Invalid(fmt::format("{} contains an empty option key.", option_key));
         }
         std::string key = member->name.GetString();
+        if (StringUtils::IsEmptyAfterTrim(key)) {
+            return Status::Invalid(fmt::format("{} contains an empty option key.", option_key));
+        }
         if (member->value.IsNull()) {
             return Status::Invalid(
                 fmt::format("{} value for key {} must not be null.", option_key, key));

test/inte/variant_table_inte_test.cpp

@@ -179,7 +179,6 @@ class VariantTableInteTest : public ::testing::Test {
                                                                 double admission_ratio,
                                                                 double retention_ratio) const {
         return {
-
             {Options::FILE_FORMAT, "parquet"},
             {Options::BUCKET, "-1"},
             {Options::WRITE_ONLY, "true"},