update

Author: HeartLinked

src/iceberg/catalog/rest/CMakeLists.txt

@@ -23,7 +23,8 @@ set(ICEBERG_REST_SOURCES
     json_internal.cc
     resource_paths.cc
     rest_catalog.cc
-    rest_util.cc)
+    rest_util.cc
+    types.cc)
 
 set(ICEBERG_REST_STATIC_BUILD_INTERFACE_LIBS)
 set(ICEBERG_REST_SHARED_BUILD_INTERFACE_LIBS)

src/iceberg/catalog/rest/json_internal.cc

@@ -364,8 +364,8 @@ Result<CreateTableRequest> CreateTableRequestFromJson(const nlohmann::json& json
   ICEBERG_ASSIGN_OR_RAISE(request.name, GetJsonValue<std::string>(json, kName));
   ICEBERG_ASSIGN_OR_RAISE(request.location,
                           GetJsonValueOrDefault<std::string>(json, kLocation));
-  ICEBERG_ASSIGN_OR_RAISE(auto schema_json, GetJsonValue<nlohmann::json>(json, kSchema));
-  ICEBERG_ASSIGN_OR_RAISE(request.schema, SchemaFromJson(schema_json));
+  ICEBERG_ASSIGN_OR_RAISE(auto schema, GetJsonValue<nlohmann::json>(json, kSchema));
+  ICEBERG_ASSIGN_OR_RAISE(request.schema, SchemaFromJson(schema));
 
   if (json.contains(kPartitionSpec)) {
     ICEBERG_ASSIGN_OR_RAISE(auto partition_spec,
@@ -375,10 +375,10 @@ Result<CreateTableRequest> CreateTableRequestFromJson(const nlohmann::json& json
                                                   PartitionSpec::kInitialSpecId));
   }
   if (json.contains(kWriteOrder)) {
-    ICEBERG_ASSIGN_OR_RAISE(auto sort_order_json,
+    ICEBERG_ASSIGN_OR_RAISE(auto sort_order,
                             GetJsonValue<nlohmann::json>(json, kWriteOrder));
     ICEBERG_ASSIGN_OR_RAISE(request.write_order,
-                            SortOrderFromJson(sort_order_json, request.schema));
+                            SortOrderFromJson(sort_order, request.schema));
   }
 
   ICEBERG_ASSIGN_OR_RAISE(request.stage_create,

src/iceberg/catalog/rest/rest_catalog.cc

@@ -81,6 +81,9 @@ RestCatalog::~RestCatalog() = default;
 Result<std::shared_ptr<RestCatalog>> RestCatalog::Make(
     const RestCatalogProperties& config, std::shared_ptr<FileIO> file_io) {
   ICEBERG_ASSIGN_OR_RAISE(auto uri, config.Uri());
+  if (!file_io) {
+    return RestError("FileIO instance is required to create RestCatalog");
+  }
   ICEBERG_ASSIGN_OR_RAISE(
       auto paths, ResourcePaths::Make(std::string(TrimTrailingSlash(uri)),
                                       config.Get(RestCatalogProperties::kPrefix)));

src/iceberg/catalog/rest/types.cc

@@ -0,0 +1,76 @@
+/*
+ * 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/catalog/rest/types.h"
+
+#include "iceberg/partition_spec.h"
+#include "iceberg/schema.h"
+#include "iceberg/sort_order.h"
+#include "iceberg/table_metadata.h"
+
+namespace iceberg::rest {
+
+bool CreateTableRequest::operator==(const CreateTableRequest& other) const {
+  if (name != other.name || location != other.location ||
+      stage_create != other.stage_create || properties != other.properties) {
+    return false;
+  }
+
+  if (!schema != !other.schema) {
+    return false;
+  }
+  if (schema && *schema != *other.schema) {
+    return false;
+  }
+
+  if (!partition_spec != !other.partition_spec) {
+    return false;
+  }
+  if (partition_spec && *partition_spec != *other.partition_spec) {
+    return false;
+  }
+
+  if (!write_order != !other.write_order) {
+    return false;
+  }
+  if (write_order && *write_order != *other.write_order) {
+    return false;
+  }
+
+  return true;
+}
+
+bool LoadTableResult::operator==(const LoadTableResult& other) const {
+  // Compare primitive fields
+  if (metadata_location != other.metadata_location || config != other.config) {
+    return false;
+  }
+
+  // Compare metadata (required) - deep comparison
+  if (!metadata != !other.metadata) {
+    return false;  // One is null, the other isn't
+  }
+  if (metadata && *metadata != *other.metadata) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace iceberg::rest

src/iceberg/catalog/rest/types.h

@@ -159,6 +159,8 @@ struct ICEBERG_REST_EXPORT CreateTableRequest {
     }
     return {};
   }
+
+  bool operator==(const CreateTableRequest& other) const;
 };
 
 /// \brief An opaque token that allows clients to make use of pagination for list APIs.
@@ -179,7 +181,7 @@ struct ICEBERG_REST_EXPORT LoadTableResult {
     return {};
   }
 
-  bool operator==(const LoadTableResult&) const = default;
+  bool operator==(const LoadTableResult& other) const;
 };
 
 /// \brief Alias of LoadTableResult used as the body of CreateTableResponse

src/iceberg/table_metadata.cc

@@ -157,6 +157,7 @@ bool operator==(const TableMetadata& lhs, const TableMetadata& rhs) {
          lhs.last_column_id == rhs.last_column_id &&
          lhs.current_schema_id == rhs.current_schema_id &&
          SharedPtrVectorEquals(lhs.schemas, rhs.schemas) &&
+         SharedPtrVectorEquals(lhs.partition_specs, rhs.partition_specs) &&
          lhs.default_spec_id == rhs.default_spec_id &&
          lhs.last_partition_id == rhs.last_partition_id &&
          lhs.properties == rhs.properties &&

src/iceberg/test/rest_catalog_test.cc

@@ -133,7 +133,7 @@ class RestCatalogIntegrationTest : public ::testing::Test {
         .Set(RestCatalogProperties::kName, std::string(kCatalogName))
         .Set(RestCatalogProperties::kWarehouse, std::string(kWarehouseName));
     auto file_io = std::make_shared<test::StdFileIO>();
-    return RestCatalog::Make(*config, file_io);
+    return RestCatalog::Make(*config, std::make_shared<test::StdFileIO>());
   }
 
   static inline std::unique_ptr<DockerCompose> docker_compose_;