fix: resolve linter errors in avro_reader_benchmark.cc

Fix clang-tidy errors reported by CI:
- Use Status.has_error() instead of .ok() (Status is std::expected)
- Use Status.error().message instead of .message
- Use std::move() for unique_ptr to shared_ptr conversion
- Remove 'using namespace' directives per google-build-using-namespace
- Fully qualify all type names with iceberg:: namespace

All tests passing, clang-tidy clean.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: shangxinli

src/iceberg/test/avro_reader_benchmark.cc

@@ -43,8 +43,8 @@ class AvroReaderBenchmark {
                       const std::string& path) {
     ArrowSchema arrow_c_schema;
     auto status = ToArrowSchema(*schema, &arrow_c_schema);
-    if (!status.ok()) {
-      std::cerr << "Failed to convert schema: " << status.message << std::endl;
+    if (status.has_error()) {
+      std::cerr << "Failed to convert schema: " << status.error().message << std::endl;
       return;
     }
 
@@ -81,14 +81,14 @@ class AvroReaderBenchmark {
     auto writer = std::move(writer_result.value());
 
     status = writer->Write(&arrow_array);
-    if (!status.ok()) {
-      std::cerr << "Failed to write: " << status.message << std::endl;
+    if (status.has_error()) {
+      std::cerr << "Failed to write: " << status.error().message << std::endl;
       return;
     }
 
     status = writer->Close();
-    if (!status.ok()) {
-      std::cerr << "Failed to close: " << status.message << std::endl;
+    if (status.has_error()) {
+      std::cerr << "Failed to close: " << status.error().message << std::endl;
       return;
     }
 
@@ -97,19 +97,19 @@ class AvroReaderBenchmark {
 
   double BenchmarkRead(const std::string& path, std::shared_ptr<Schema> schema,
                        bool use_direct_decoder, int iterations = 10) {
-    auto reader_properties = ReaderProperties::default_properties();
-    reader_properties->Set(ReaderProperties::kAvroUseDirectDecoder, use_direct_decoder);
-
     double total_time_ms = 0.0;
     int64_t total_rows = 0;
 
     for (int i = 0; i < iterations; ++i) {
-      auto reader_result = ReaderFactoryRegistry::Open(FileFormatType::kAvro,
-                                                       {.path = path,
-                                                        .length = file_length_,
-                                                        .io = file_io_,
-                                                        .projection = schema,
-                                                        .properties = reader_properties});
+      auto reader_properties = ReaderProperties::default_properties();
+      reader_properties->Set(ReaderProperties::kAvroUseDirectDecoder, use_direct_decoder);
+
+      auto reader_result = ReaderFactoryRegistry::Open(
+          FileFormatType::kAvro, {.path = path,
+                                  .length = file_length_,
+                                  .io = file_io_,
+                                  .projection = schema,
+                                  .properties = std::move(reader_properties)});
       if (!reader_result.has_value()) {
         std::cerr << "Failed to open reader: " << reader_result.error().message
                   << std::endl;
@@ -141,8 +141,9 @@ class AvroReaderBenchmark {
       total_rows = batch_rows;
 
       auto close_status = reader->Close();
-      if (!close_status.ok()) {
-        std::cerr << "Failed to close reader: " << close_status.message << std::endl;
+      if (close_status.has_error()) {
+        std::cerr << "Failed to close reader: " << close_status.error().message
+                  << std::endl;
         return -1;
       }
     }
@@ -178,17 +179,16 @@ class AvroReaderBenchmark {
 }  // namespace iceberg::avro
 
 int main() {
-  using namespace iceberg;
-  using namespace iceberg::avro;
-
-  AvroReaderBenchmark benchmark;
+  iceberg::avro::AvroReaderBenchmark benchmark;
 
   // Benchmark 1: Simple primitive types
   {
-    auto schema = std::make_shared<Schema>(std::vector<SchemaField>{
-        SchemaField::MakeRequired(1, "id", std::make_shared<IntType>()),
-        SchemaField::MakeRequired(2, "value", std::make_shared<DoubleType>()),
-        SchemaField::MakeRequired(3, "name", std::make_shared<StringType>())});
+    auto schema = std::make_shared<iceberg::Schema>(std::vector<iceberg::SchemaField>{
+        iceberg::SchemaField::MakeRequired(1, "id", std::make_shared<iceberg::IntType>()),
+        iceberg::SchemaField::MakeRequired(2, "value",
+                                           std::make_shared<iceberg::DoubleType>()),
+        iceberg::SchemaField::MakeRequired(3, "name",
+                                           std::make_shared<iceberg::StringType>())});
 
     std::ostringstream json;
     json << "[";
@@ -203,15 +203,17 @@ int main() {
 
   // Benchmark 2: Nested structs
   {
-    auto schema = std::make_shared<Schema>(std::vector<SchemaField>{
-        SchemaField::MakeRequired(1, "id", std::make_shared<IntType>()),
-        SchemaField::MakeRequired(
+    auto schema = std::make_shared<iceberg::Schema>(std::vector<iceberg::SchemaField>{
+        iceberg::SchemaField::MakeRequired(1, "id", std::make_shared<iceberg::IntType>()),
+        iceberg::SchemaField::MakeRequired(
             2, "data",
-            std::make_shared<StructType>(std::vector<SchemaField>{
-                SchemaField::MakeRequired(3, "x", std::make_shared<DoubleType>()),
-                SchemaField::MakeRequired(4, "y", std::make_shared<DoubleType>()),
-                SchemaField::MakeRequired(5, "label",
-                                          std::make_shared<StringType>())}))});
+            std::make_shared<iceberg::StructType>(std::vector<iceberg::SchemaField>{
+                iceberg::SchemaField::MakeRequired(
+                    3, "x", std::make_shared<iceberg::DoubleType>()),
+                iceberg::SchemaField::MakeRequired(
+                    4, "y", std::make_shared<iceberg::DoubleType>()),
+                iceberg::SchemaField::MakeRequired(
+                    5, "label", std::make_shared<iceberg::StringType>())}))});
 
     std::ostringstream json;
     json << "[";
@@ -227,11 +229,12 @@ int main() {
 
   // Benchmark 3: Lists
   {
-    auto schema = std::make_shared<Schema>(std::vector<SchemaField>{
-        SchemaField::MakeRequired(1, "id", std::make_shared<IntType>()),
-        SchemaField::MakeRequired(2, "values",
-                                  std::make_shared<ListType>(SchemaField::MakeRequired(
-                                      3, "element", std::make_shared<IntType>())))});
+    auto schema = std::make_shared<iceberg::Schema>(std::vector<iceberg::SchemaField>{
+        iceberg::SchemaField::MakeRequired(1, "id", std::make_shared<iceberg::IntType>()),
+        iceberg::SchemaField::MakeRequired(
+            2, "values",
+            std::make_shared<iceberg::ListType>(iceberg::SchemaField::MakeRequired(
+                3, "element", std::make_shared<iceberg::IntType>())))});
 
     std::ostringstream json;
     json << "[";
@@ -251,10 +254,12 @@ int main() {
 
   // Benchmark 4: Optional fields with nulls
   {
-    auto schema = std::make_shared<Schema>(std::vector<SchemaField>{
-        SchemaField::MakeRequired(1, "id", std::make_shared<IntType>()),
-        SchemaField::MakeOptional(2, "opt_int", std::make_shared<IntType>()),
-        SchemaField::MakeOptional(3, "opt_string", std::make_shared<StringType>())});
+    auto schema = std::make_shared<iceberg::Schema>(std::vector<iceberg::SchemaField>{
+        iceberg::SchemaField::MakeRequired(1, "id", std::make_shared<iceberg::IntType>()),
+        iceberg::SchemaField::MakeOptional(2, "opt_int",
+                                           std::make_shared<iceberg::IntType>()),
+        iceberg::SchemaField::MakeOptional(3, "opt_string",
+                                           std::make_shared<iceberg::StringType>())});
 
     std::ostringstream json;
     json << "[";