remove most unnecessary lines to focus on interface design

Author: wgtmac

src/iceberg/CMakeLists.txt

@@ -22,7 +22,6 @@ set(ICEBERG_SOURCES
     catalog/memory/in_memory_catalog.cc
     data/data_writer.cc
     data/equality_delete_writer.cc
-    data/file_writer_factory.cc
     data/position_delete_writer.cc
     data/writer.cc
     delete_file_index.cc

src/iceberg/data/data_writer.cc

@@ -21,53 +21,18 @@
 
 namespace iceberg {
 
-//=============================================================================
-// DataWriter - stub implementation (to be completed in separate PR per #441)
-//=============================================================================
-
 class DataWriter::Impl {
  public:
-  explicit Impl(DataWriterOptions options) : options_(std::move(options)) {}
-  DataWriterOptions options_;
-  bool is_closed_ = false;
 };
 
-DataWriter::DataWriter(std::unique_ptr<Impl> impl) : impl_(std::move(impl)) {}
 DataWriter::~DataWriter() = default;
 
-Status DataWriter::Write(ArrowArray* data) {
-  if (!data) {
-    return InvalidArgument("Cannot write null data");
-  }
-  if (impl_->is_closed_) {
-    return Invalid("Writer is already closed");
-  }
-  return NotImplemented("DataWriter not yet implemented - see #441");
-}
-
-Result<int64_t> DataWriter::Length() const {
-  return NotImplemented("DataWriter not yet implemented - see #441");
-}
+Status DataWriter::Write(ArrowArray* data) { return NotImplemented(""); }
 
-Status DataWriter::Close() {
-  if (impl_->is_closed_) {
-    return {};  // Close is idempotent
-  }
-  impl_->is_closed_ = true;
-  return NotImplemented("DataWriter not yet implemented - see #441");
-}
+Result<int64_t> DataWriter::Length() const { return NotImplemented(""); }
 
-Result<FileWriter::WriteResult> DataWriter::Metadata() {
-  if (!impl_->is_closed_) {
-    return Invalid("Writer must be closed before getting metadata");
-  }
-  return NotImplemented("DataWriter not yet implemented - see #441");
-}
+Status DataWriter::Close() { return NotImplemented(""); }
 
-// Internal factory function for FileWriterFactory
-std::unique_ptr<DataWriter> MakeDataWriterInternal(const DataWriterOptions& options) {
-  auto impl = std::make_unique<DataWriter::Impl>(options);
-  return std::unique_ptr<DataWriter>(new DataWriter(std::move(impl)));
-}
+Result<FileWriter::WriteResult> DataWriter::Metadata() { return NotImplemented(""); }
 
 }  // namespace iceberg

src/iceberg/data/data_writer.h

@@ -26,6 +26,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <unordered_map>
 
 #include "iceberg/arrow_c_data.h"
 #include "iceberg/data/writer.h"
@@ -38,11 +39,6 @@
 namespace iceberg {
 
 /// \brief Options for creating a DataWriter.
-///
-/// \note The following features from Java DataWriter are not yet supported:
-/// - Encryption key metadata (uses FileIO instead of EncryptedOutputFile)
-/// - Metrics collection and reporting
-/// - Split offsets tracking
 struct ICEBERG_EXPORT DataWriterOptions {
   std::string path;
   std::shared_ptr<Schema> schema;
@@ -51,13 +47,10 @@ struct ICEBERG_EXPORT DataWriterOptions {
   FileFormatType format = FileFormatType::kParquet;
   std::shared_ptr<FileIO> io;
   std::optional<int32_t> sort_order_id;
-  std::shared_ptr<class WriterProperties> properties;
+  std::unordered_map<std::string, std::string> properties;
 };
 
 /// \brief Writer for Iceberg data files.
-///
-/// \warning Thread Safety: Writer instances are NOT thread-safe. Each writer should only
-/// be used by a single thread. Do not call Write(), Close(), or Metadata() concurrently.
 class ICEBERG_EXPORT DataWriter : public FileWriter {
  public:
   ~DataWriter() override;
@@ -68,11 +61,8 @@ class ICEBERG_EXPORT DataWriter : public FileWriter {
   Result<WriteResult> Metadata() override;
 
  private:
-  friend class FileWriterFactory;
-  friend std::unique_ptr<DataWriter> MakeDataWriterInternal(const DataWriterOptions&);
   class Impl;
   std::unique_ptr<Impl> impl_;
-  explicit DataWriter(std::unique_ptr<Impl> impl);
 };
 
 }  // namespace iceberg

src/iceberg/data/equality_delete_writer.cc

@@ -21,59 +21,22 @@
 
 namespace iceberg {
 
-//=============================================================================
-// EqualityDeleteWriter - stub implementation (to be completed in separate PR per #441)
-//=============================================================================
-
 class EqualityDeleteWriter::Impl {
  public:
-  explicit Impl(EqualityDeleteWriterOptions options) : options_(std::move(options)) {}
-  EqualityDeleteWriterOptions options_;
-  bool is_closed_ = false;
 };
 
-EqualityDeleteWriter::EqualityDeleteWriter(std::unique_ptr<Impl> impl)
-    : impl_(std::move(impl)) {}
 EqualityDeleteWriter::~EqualityDeleteWriter() = default;
 
-Status EqualityDeleteWriter::Write(ArrowArray* data) {
-  if (!data) {
-    return InvalidArgument("Cannot write null data");
-  }
-  if (impl_->is_closed_) {
-    return Invalid("Writer is already closed");
-  }
-  return NotImplemented("EqualityDeleteWriter not yet implemented - see #441");
-}
+Status EqualityDeleteWriter::Write(ArrowArray* data) { return NotImplemented(""); }
 
-Result<int64_t> EqualityDeleteWriter::Length() const {
-  return NotImplemented("EqualityDeleteWriter not yet implemented - see #441");
-}
+Result<int64_t> EqualityDeleteWriter::Length() const { return NotImplemented(""); }
 
-Status EqualityDeleteWriter::Close() {
-  if (impl_->is_closed_) {
-    return {};  // Close is idempotent
-  }
-  impl_->is_closed_ = true;
-  return NotImplemented("EqualityDeleteWriter not yet implemented - see #441");
-}
+Status EqualityDeleteWriter::Close() { return NotImplemented(""); }
 
 Result<FileWriter::WriteResult> EqualityDeleteWriter::Metadata() {
-  if (!impl_->is_closed_) {
-    return Invalid("Writer must be closed before getting metadata");
-  }
-  return NotImplemented("EqualityDeleteWriter not yet implemented - see #441");
+  return NotImplemented("");
 }
 
-const std::vector<int32_t>& EqualityDeleteWriter::equality_field_ids() const {
-  return impl_->options_.equality_field_ids;
-}
-
-// Internal factory function for FileWriterFactory
-std::unique_ptr<EqualityDeleteWriter> MakeEqualityDeleteWriterInternal(
-    const EqualityDeleteWriterOptions& options) {
-  auto impl = std::make_unique<EqualityDeleteWriter::Impl>(options);
-  return std::unique_ptr<EqualityDeleteWriter>(new EqualityDeleteWriter(std::move(impl)));
-}
+std::span<const int32_t> EqualityDeleteWriter::equality_field_ids() const { return {}; }
 
 }  // namespace iceberg

src/iceberg/data/equality_delete_writer.h

@@ -25,8 +25,9 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
-#include <vector>
+#include <unordered_map>
 
 #include "iceberg/arrow_c_data.h"
 #include "iceberg/data/writer.h"
@@ -39,11 +40,6 @@
 namespace iceberg {
 
 /// \brief Options for creating an EqualityDeleteWriter.
-///
-/// \note The following features from Java EqualityDeleteWriter are not yet supported:
-/// - Encryption key metadata
-/// - Metrics collection and reporting
-/// - Split offsets tracking
 struct ICEBERG_EXPORT EqualityDeleteWriterOptions {
   std::string path;
   std::shared_ptr<Schema> schema;
@@ -53,13 +49,10 @@ struct ICEBERG_EXPORT EqualityDeleteWriterOptions {
   std::shared_ptr<FileIO> io;
   std::vector<int32_t> equality_field_ids;
   std::optional<int32_t> sort_order_id;
-  std::shared_ptr<class WriterProperties> properties;
+  std::unordered_map<std::string, std::string> properties;
 };
 
 /// \brief Writer for Iceberg equality delete files.
-///
-/// \warning Thread Safety: Writer instances are NOT thread-safe. Each writer should only
-/// be used by a single thread. Do not call Write(), Close(), or Metadata() concurrently.
 class ICEBERG_EXPORT EqualityDeleteWriter : public FileWriter {
  public:
   ~EqualityDeleteWriter() override;
@@ -69,15 +62,11 @@ class ICEBERG_EXPORT EqualityDeleteWriter : public FileWriter {
   Status Close() override;
   Result<WriteResult> Metadata() override;
 
-  const std::vector<int32_t>& equality_field_ids() const;
+  std::span<const int32_t> equality_field_ids() const;
 
  private:
-  friend class FileWriterFactory;
-  friend std::unique_ptr<EqualityDeleteWriter> MakeEqualityDeleteWriterInternal(
-      const EqualityDeleteWriterOptions&);
   class Impl;
   std::unique_ptr<Impl> impl_;
-  explicit EqualityDeleteWriter(std::unique_ptr<Impl> impl);
 };
 
 }  // namespace iceberg