docs(ingester): Update references to `DmlOperation` in doc comments

ingester/src/buffer_tree/namespace.rs

@@ -58,7 +58,7 @@ pub(crate) struct NamespaceData<O> {
     namespace_name: Arc<DeferredLoad<NamespaceName>>,
 
     /// A set of tables this [`NamespaceData`] instance has processed
-    /// [`DmlOperation`]'s for.
+    /// [`IngestOp`]'s for.
     ///
     /// The [`TableNameProvider`] acts as a [`DeferredLoad`] constructor to
     /// resolve the [`TableName`] for new [`TableData`] out of the hot path.

ingester/src/buffer_tree/root.rs

@@ -50,10 +50,10 @@ use crate::{
 /// ```
 ///
 /// A buffer tree is a mutable data structure that implements [`DmlSink`] to
-/// apply successive [`DmlOperation`] to its internal state, and makes the
+/// apply successive [`IngestOp`] to its internal state, and makes the
 /// materialised result available through a streaming [`QueryExec`] execution.
 ///
-/// The tree is populated lazily/on-demand as [`DmlOperation`] are applied or
+/// The tree is populated lazily/on-demand as [`IngestOp`] are applied or
 /// the data is accessed, but some information is pre-cached and made available
 /// to the [`BufferTree`] for performance reasons (see [`PartitionCache`]).
 ///
@@ -82,7 +82,7 @@ pub(crate) struct BufferTree<O> {
     partition_provider: Arc<dyn PartitionProvider>,
 
     /// A set of namespaces this [`BufferTree`] instance has processed
-    /// [`DmlOperation`]'s for.
+    /// [`IngestOp`]'s for.
     ///
     /// The [`NamespaceNameProvider`] acts as a [`DeferredLoad`] constructor to
     /// resolve the [`NamespaceName`] for new [`NamespaceData`] out of the hot

ingester/src/init/wal_replay.rs

@@ -25,11 +25,11 @@ pub enum WalReplayError {
     #[error("failed to read wal entry: {0}")]
     ReadEntry(wal::Error),
 
-    /// An error converting the WAL entry into a [`DmlOperation`].
+    /// An error converting the WAL entry into a [`IngestOp`].
-    #[error("failed converting wal entry to dml operation: {0}")]
+    #[error("failed converting wal entry to ingest operation: {0}")]
     MapToDml(#[from] mutable_batch_pb::decode::Error),
 
-    /// A failure to apply a [`DmlOperation`] from the WAL to the in-memory
+    /// A failure to apply a [`IngestOp`] from the WAL to the in-memory
     /// [`BufferTree`].
     ///
     /// [`BufferTree`]: crate::buffer_tree::BufferTree

ingester/src/server/grpc/rpc_write.rs

@@ -106,7 +106,7 @@ pub(crate) struct RpcWrite<T> {
 }
 
 impl<T> RpcWrite<T> {
-    /// Instantiate a new [`RpcWrite`] that pushes [`DmlOperation`] instances
+    /// Instantiate a new [`RpcWrite`] that pushes [`IngestOp`] instances
     /// into `sink`.
     pub(crate) fn new(
         sink: T,

ingester/src/wal/mod.rs

@@ -1,8 +1,8 @@
-//! A [`DmlSink`] decorator to make request [`DmlOperation`] durable in a
+//! A [`DmlSink`] decorator to make request [`IngestOp`] durable in a
 //! write-ahead log.
 //!
 //! [`DmlSink`]: crate::dml_sink::DmlSink
-//! [`DmlOperation`]: dml::DmlOperation
+//! [`IngestOp`]: crate::dml_payload::IngestOp
 
 pub(crate) mod reference_tracker;
 pub(crate) mod rotate_task;

ingester/src/wal/wal_sink.rs

@@ -24,11 +24,11 @@ use super::traits::WalAppender;
 /// problem (catalog unavailable, etc) preventing a write from making progress.
 const DELEGATE_APPLY_TIMEOUT: Duration = Duration::from_secs(15);
 
-/// A [`DmlSink`] decorator that ensures any [`DmlOperation`] is committed to
+/// A [`DmlSink`] decorator that ensures any [`IngestOp`] is committed to
 /// the write-ahead log before passing the operation to the inner [`DmlSink`].
 #[derive(Debug)]
 pub(crate) struct WalSink<T, W = wal::Wal> {
-    /// The inner chain of [`DmlSink`] that a [`DmlOperation`] is passed to once
+    /// The inner chain of [`DmlSink`] that a [`IngestOp`] is passed to once
     /// committed to the write-ahead log.
     inner: T,
 
@@ -37,7 +37,7 @@ pub(crate) struct WalSink<T, W = wal::Wal> {
 }
 
 impl<T, W> WalSink<T, W> {
-    /// Initialise a new [`WalSink`] that appends [`DmlOperation`] to `W` and
+    /// Initialise a new [`WalSink`] that appends [`IngestOp`] to `W` and
     /// on success, passes the op through to `T`.
     pub(crate) fn new(inner: T, wal: W) -> Self {
         Self { inner, wal }