@@ -68,8 +68,6 @@ pub struct ChunkPlanner {
     selection: Selection,
     /// The rows zone pruning kept, over `rows`, or `None` when nothing was pruned.
     kept: Option<Mask>,
-    /// Whether the chunks run as children of this planner instead of being spawned.
-    inline: bool,
 }
 
 impl ChunkPlanner {
@@ -81,42 +79,15 @@ impl ChunkPlanner {
         selection: Selection,
         kept: Option<Mask>,
     ) -> Self {
-        let chunks = row_chunks(rows.clone(), scan.chunk_rows);
-        Self::with_chunks(scan, rows, chunks, selection, kept)
-    }
-
-    /// The planner of `chunks`, which tile `rows` in row order, for a driver that cuts the rows
-    /// itself, such as on the file's own chunk boundaries.
-    pub fn with_chunks(
-        scan: Arc<PreparedScan>,
-        rows: Range<u64>,
-        chunks: Vec<Range<u64>>,
-        selection: Selection,
-        kept: Option<Mask>,
-    ) -> Self {
-        debug_assert!(
-            chunks.first().is_none_or(|chunk| chunk.start == rows.start)
-                && chunks.last().is_none_or(|chunk| chunk.end == rows.end)
-                && chunks.windows(2).all(|pair| pair[0].end == pair[1].start),
-            "chunks must tile the rows in order"
-        );
+        let chunks = row_chunks(rows.clone(), scan.chunk_rows).into_iter();
         Self {
             scan,
             rows,
-            chunks: chunks.into_iter(),
+            chunks,
             selection,
             kept,
-            inline: false,
         }
     }
-
-    /// Runs the chunks as children of this planner, on its run and IO session, instead of
-    /// spawning them for the driver to place. Chunks that read the same segment, such as a
-    /// column chunk longer than the scan's chunks, then share the read.
-    pub fn inline(mut self) -> Self {
-        self.inline = true;
-        self
-    }
 }
 
 impl IoConsumer for ChunkPlanner {
@@ -141,11 +112,7 @@ impl Planner for ChunkPlanner {
             };
             if let Some((scope, planner)) = plan_selection(&self.scan, scope, &self.selection, kept)
             {
-                return Ok(if self.inline {
-                    PlannerOutput::Planner(scope, planner)
-                } else {
-                    PlannerOutput::Spawn(scope, planner)
-                });
+                return Ok(PlannerOutput::Spawn(scope, planner));
             }
         }
         Ok(PlannerOutput::Done)
 
@@ -71,9 +71,6 @@ impl SegmentLocation {
     }
 }
 
-/// A selection of at most one row in this many of a scan's rows is sparse.
-const SPARSE_SELECTION: u64 = 1024;
-
 /// A scan's plans over one file, built once from the file's footer and read by every planner of
 /// the scan. Nothing here touches a segment, and no planner plans again.
 pub struct PreparedScan {
@@ -121,32 +118,12 @@ impl PreparedScan {
         self.filter.as_deref()
     }
 
-    /// The most rows of one chunk a [`ChunkPlanner`] cuts the scan's rows into.
-    pub fn chunk_rows(&self) -> usize {
-        self.chunk_rows
-    }
-
-    /// Whether the scan selects at most one row in 1024 of its rows, as an
-    /// engine fetching a few rows by id does.
-    pub fn sparse_selection(&self) -> bool {
-        !matches!(self.selection, Selection::All)
-            && self
-                .selection
-                .row_count_in_range(&self.rows)
-                .saturating_mul(SPARSE_SELECTION)
-                <= self.rows.end - self.rows.start
-    }
-
     /// The service a driver takes IO sessions from: every read a planner of the scan requests is
     /// served from it by segment.
-    ///
-    /// A [sparse selection](Self::sparse_selection) retains its reads for the scan's lifetime,
-    /// as the chunks that select its few rows read the same wide segments one after another.
     pub fn io(&self) -> Arc<dyn IoService> {
         Arc::new(SegmentScanIo::new(
             Arc::clone(&self.segments),
             Arc::clone(&self.ranges),
-            self.sparse_selection(),
         ))
     }
 
 
@@ -12,7 +12,6 @@ use futures::StreamExt;
 use futures::TryFutureExt;
 use futures::future::BoxFuture;
 use futures::future::Shared;
-use futures::future::WeakShared;
 use futures::stream::FuturesUnordered;
 use parking_lot::Mutex;
 use vortex_array::buffer::BufferHandle;
@@ -47,89 +46,26 @@ pub(super) fn segment_ranges(locations: &[SegmentLocation]) -> SegmentRanges {
 }
 
 /// Serves splits from any [`SegmentSource`], by segment id.
-///
-/// Its sessions share a segment's read while any of them still holds it, so splits that run at
-/// once and need the same segment, such as chunks that each cut into one column segment, read
-/// it once. A scan that retains its reads keeps every read for its lifetime, so splits that run
-/// one after another share them too.
 pub(crate) struct SegmentScanIo {
     segments: Arc<dyn SegmentSource>,
     ranges: SegmentRanges,
-    reads: SharedReads,
 }
 
 impl SegmentScanIo {
-    /// A scan's IO, which retains its reads when `retain` is set.
-    ///
-    /// Retaining suits a sparse selection, such as an engine fetching a few rows by id: its
-    /// reads are few, but each wide column segment it touches is needed by every chunk that
-    /// selects a row of it.
-    pub(crate) fn new(
-        segments: Arc<dyn SegmentSource>,
-        ranges: SegmentRanges,
-        retain: bool,
-    ) -> Self {
-        Self {
-            segments,
-            ranges,
-            reads: Arc::new(Mutex::new(ScanReads {
-                retain,
-                reads: HashMap::default(),
-            })),
-        }
+    pub(crate) fn new(segments: Arc<dyn SegmentSource>, ranges: SegmentRanges) -> Self {
+        Self { segments, ranges }
     }
 }
 
 impl IoService for SegmentScanIo {
     fn session(&self) -> Arc<dyn IoSource> {
-        Arc::new(SegmentIoSource::with_shared_reads(
+        Arc::new(SegmentIoSource::new(
             Arc::clone(&self.segments),
             Arc::clone(&self.ranges),
-            Arc::clone(&self.reads),
         ))
     }
 }
 
-/// The reads of a scan's sessions, by segment.
-type SharedReads = Arc<Mutex<ScanReads>>;
-
-/// The reads of a scan's sessions, by segment.
-#[derive(Default)]
-struct ScanReads {
-    /// Whether reads are held for the scan's lifetime rather than while a session holds them.
-    retain: bool,
-    reads: HashMap<SegmentId, ScanRead>,
-}
-
-/// A read of a scan, held weakly so that sharing it keeps no segment in memory longer, or
-/// retained.
-enum ScanRead {
-    Weak(WeakShared<SegmentRead>),
-    Retained(Prefetched),
-}
-
-impl ScanReads {
-    /// The read of `segment` the scan still has.
-    fn get(&self, segment: SegmentId) -> Option<Prefetched> {
-        match self.reads.get(&segment)? {
-            ScanRead::Weak(read) => read.upgrade(),
-            ScanRead::Retained(read) => Some(read.clone()),
-        }
-    }
-
-    fn insert(&mut self, segment: SegmentId, read: &Prefetched) {
-        let read = if self.retain {
-            ScanRead::Retained(read.clone())
-        } else {
-            let Some(read) = read.downgrade() else {
-                return;
-            };
-            ScanRead::Weak(read)
-        };
-        self.reads.insert(segment, read);
-    }
-}
-
 /// Serves a split's range requests from a segment source, without blocking.
 ///
 /// Each requested range names one segment. [`submit`](IoSource::submit) starts its read at once,
@@ -149,57 +85,22 @@ pub(super) struct SegmentIoSource {
     prefetched: Mutex<HashMap<SegmentId, Prefetched>>,
     /// Announced segments, requested and never polled.
     announced: Mutex<HashMap<SegmentId, VecDeque<SegmentFuture>>>,
-    /// The reads of the scan's other sessions.
-    shared: SharedReads,
 }
 
-/// The read of a segment.
-type SegmentRead = BoxFuture<'static, Result<BufferHandle, Arc<VortexError>>>;
-
 /// A read started ahead of the fetch that needs it.
-type Prefetched = Shared<SegmentRead>;
+type Prefetched = Shared<BoxFuture<'static, Result<BufferHandle, Arc<VortexError>>>>;
 
 impl SegmentIoSource {
-    #[cfg(test)]
     pub(super) fn new(segments: Arc<dyn SegmentSource>, ranges: SegmentRanges) -> Self {
-        Self::with_shared_reads(segments, ranges, SharedReads::default())
-    }
-
-    fn with_shared_reads(
-        segments: Arc<dyn SegmentSource>,
-        ranges: SegmentRanges,
-        shared: SharedReads,
-    ) -> Self {
         Self {
             segments,
             ranges,
             reads: Mutex::new(FuturesUnordered::new()),
             ready: Mutex::default(),
             prefetched: Mutex::default(),
             announced: Mutex::default(),
-            shared,
         }
     }
-
-    /// The read of `segment`: one another session of the scan still holds, else the read of an
-    /// announcement of it, else a new one.
-    fn read(&self, segment: SegmentId) -> Prefetched {
-        let mut shared = self.shared.lock();
-        if let Some(read) = shared.get(segment) {
-            return read;
-        }
-        let read = self
-            .announced
-            .lock()
-            .get_mut(&segment)
-            .and_then(VecDeque::pop_front)
-            .unwrap_or_else(|| self.segments.request(segment))
-            .map_err(Arc::new)
-            .boxed()
-            .shared();
-        shared.insert(segment, &read);
-        read
-    }
 }
 
 impl IoSource for SegmentIoSource {
@@ -228,7 +129,15 @@ impl IoSource for SegmentIoSource {
             }
             if request.intent == IoIntent::Prefetch {
                 prefetched.entry(segment).or_insert_with(|| {
-                    let read = self.read(segment);
+                    let read = self
+                        .announced
+                        .lock()
+                        .get_mut(&segment)
+                        .and_then(VecDeque::pop_front)
+                        .unwrap_or_else(|| self.segments.request(segment))
+                        .map_err(Arc::new)
+                        .boxed()
+                        .shared();
                     // Polling registers the read as wanted, so the source starts it now.
                     drop(
                         read.clone()
@@ -243,7 +152,16 @@ impl IoSource for SegmentIoSource {
             // first has completed.
             let mut bytes = prefetched
                 .entry(segment)
-                .or_insert_with(|| self.read(segment))
+                .or_insert_with(|| {
+                    self.announced
+                        .lock()
+                        .get_mut(&segment)
+                        .and_then(VecDeque::pop_front)
+                        .unwrap_or_else(|| self.segments.request(segment))
+                        .map_err(Arc::new)
+                        .boxed()
+                        .shared()
+                })
                 .clone()
                 .map_err(move |err| vortex_err!("read of segment {segment} failed: {err}"))
                 .boxed();
@@ -331,12 +249,10 @@ mod tests {
     use vortex_io::request::IoOwnerId;
     use vortex_io::request::IoRequest;
     use vortex_io::request::IoRequestId;
-    use vortex_io::request::IoService;
     use vortex_io::request::IoSource;
     use vortex_io::request::IoTarget;
 
     use super::SegmentIoSource;
-    use super::SegmentScanIo;
     use super::segment_ranges;
     use crate::scan::execution::SegmentLocation;
     use crate::segments::SegmentFuture;
@@ -454,75 +370,6 @@ mod tests {
         Ok(())
     }
 
-    /// Sessions of one scan share a segment's read while one of them holds it, and read it again
-    /// once none does.
-    #[tokio::test]
-    async fn sessions_share_a_held_read() -> VortexResult<()> {
-        let segments = Arc::new(CountingSegments::default());
-        let location = SegmentLocation {
-            offset: 0,
-            length: 4,
-            alignment: Alignment::none(),
-        };
-        let scan = SegmentScanIo::new(
-            Arc::clone(&segments) as _,
-            segment_ranges(&[location]),
-            false,
-        );
-        let first = scan.session();
-        let second = scan.session();
-        for (io, id) in [(&first, 0), (&second, 1)] {
-            io.submit(IoOwnerId(0), vec![request(IoIntent::Fetch, id)])?;
-            let completion = std::future::poll_fn(|cx| io.poll_completion(cx)).await?;
-            assert_eq!(completion.request, IoRequestId(id));
-            assert!(completion.result.is_ok());
-        }
-        assert_eq!(segments.0.load(Ordering::Relaxed), 1);
-
-        first.clear();
-        second.clear();
-        let third = scan.session();
-        third.submit(IoOwnerId(0), vec![request(IoIntent::Fetch, 2)])?;
-        assert!(
-            std::future::poll_fn(|cx| third.poll_completion(cx))
-                .await?
-                .result
-                .is_ok()
-        );
-        assert_eq!(segments.0.load(Ordering::Relaxed), 2);
-        Ok(())
-    }
-
-    /// A scan that retains its reads shares a read with a later session after the earlier one
-    /// let it go.
-    #[tokio::test]
-    async fn retained_reads_outlive_their_sessions() -> VortexResult<()> {
-        let segments = Arc::new(CountingSegments::default());
-        let location = SegmentLocation {
-            offset: 0,
-            length: 4,
-            alignment: Alignment::none(),
-        };
-        let scan = SegmentScanIo::new(
-            Arc::clone(&segments) as _,
-            segment_ranges(&[location]),
-            true,
-        );
-        for id in 0..2 {
-            let io = scan.session();
-            io.submit(IoOwnerId(0), vec![request(IoIntent::Fetch, id)])?;
-            assert!(
-                std::future::poll_fn(|cx| io.poll_completion(cx))
-                    .await?
-                    .result
-                    .is_ok()
-            );
-            io.clear();
-        }
-        assert_eq!(segments.0.load(Ordering::Relaxed), 1);
-        Ok(())
-    }
-
     #[tokio::test]
     async fn announcements_keep_independent_consumers() -> VortexResult<()> {
         let segments = Arc::new(CountingSegments::default());