sdd commented on code in PR #373:
URL: https://github.com/apache/iceberg-rust/pull/373#discussion_r1639394777
##########
crates/iceberg/src/scan.rs:
##########
@@ -302,13 +262,147 @@ impl TableScan {
arrow_reader_builder.build().read(self.plan_files().await?)
}
+}
+
+#[derive(Debug)]
+struct ConcurrentFileScanStreamContext {
+ context: FileScanStreamContext,
+ sender: Sender<Result<FileScanTask>>,
+ manifest_evaluator_cache: ManifestEvaluatorCache,
+ partition_filter_cache: PartitionFilterCache,
+}
+
+impl ConcurrentFileScanStreamContext {
+ fn new(context: FileScanStreamContext, sender:
Sender<Result<FileScanTask>>) -> Self {
+ ConcurrentFileScanStreamContext {
+ context,
+ sender,
+ manifest_evaluator_cache: ManifestEvaluatorCache::new(),
+ partition_filter_cache: PartitionFilterCache::new(),
+ }
+ }
+
+ async fn run(&mut self, manifest_list: ManifestList) -> Result<()> {
+ let file_io = self.context.file_io.clone();
+ let sender = self.sender.clone();
+
+ // This whole Vec-and-for-loop approach feels sub-optimally structured.
+ // I've tried structuring this in multiple ways but run into
+ // issues with ownership. Ideally I'd like to structure this
+ // with a functional programming approach: extracting
+ // sections 1, 2, and 3 out into different methods on Self,
+ // and then use some iterator combinators to orchestrate it all.
+ // Section 1 is pretty trivially refactorable into a static method
+ // that can be used in a closure that can be used with
Iterator::filter.
+ // Similarly, section 3 seems easily factor-able into a method that can
+ // be passed into Iterator::map.
+ // Section 2 turns out trickier - we want to exit the entire `run`
method early
+ // if the eval fails, and filter out any manifest_files from the
iterator / stream
+ // if the eval succeeds but returns true. We bump into ownership
issues due
+ // to needing to pass mut self as the caches need to be able to mutate.
+ // Section 3 runs into ownership issues when trying to refactor its
closure to be
+ // a static or non-static method.
+
+ // 1
+ let filtered_manifest_files = manifest_list
+ .entries()
+ .iter()
+ .filter(Self::reject_unsupported_content_types);
+
+ // 2
+ let mut filtered_manifest_files2 = vec![];
+ for manifest_file in filtered_manifest_files {
+ if !self.apply_evaluator(manifest_file)? {
+ continue;
+ }
+
+ filtered_manifest_files2.push(manifest_file);
+ }
+
+ // 3
+ let filtered_manifest_files = filtered_manifest_files2
+ .into_iter()
+ .map(|manifest_file| Ok((manifest_file, file_io.clone(),
sender.clone())));
+
+ futures::stream::iter(filtered_manifest_files)
+ .try_for_each_concurrent(
+ CONCURRENCY_LIMIT_MANIFEST_FILES,
+ Self::process_manifest_file,
+ )
+ .await
+ }
+
+ fn reject_unsupported_content_types(manifest_file: &&ManifestFile) -> bool
{
+ SUPPORTED_MANIFEST_FILE_CONTENT_TYPES.contains(&manifest_file.content)
+ }
+
+ fn apply_evaluator(&mut self, manifest_file: &ManifestFile) ->
Result<bool> {
+ let partition_spec_id = manifest_file.partition_spec_id;
+
+ let partition_filter = self
+ .partition_filter_cache
+ .get(partition_spec_id, &self.context)?;
+
+ if let Some(partition_filter) = partition_filter {
+ let manifest_evaluator = self
+ .manifest_evaluator_cache
+ .get(partition_spec_id, partition_filter);
+
+ if !manifest_evaluator.eval(manifest_file)? {
+ return Ok(false);
+ }
+ }
+
+ Ok(true)
+ }
+
+ async fn process_manifest_file(
+ manifest_and_file_io_and_sender: (&ManifestFile, FileIO,
Sender<Result<FileScanTask>>),
+ ) -> Result<()> {
+ let (manifest_file, file_io, sender) = manifest_and_file_io_and_sender;
+
+ let manifest = manifest_file.load_manifest(&file_io).await?;
+
+ let manifest_entries = manifest
+ .entries()
+ .iter()
+ .filter(|x| x.is_alive())
+ .map(|manifest_entry| Ok((manifest_entry, sender.clone())));
+
+ futures::stream::iter(manifest_entries)
+ .try_for_each_concurrent(
+ CONCURRENCY_LIMIT_MANIFEST_ENTRIES,
+ Self::process_manifest_entry,
+ )
+ .await
Review Comment:
Task spawning concurrency is limited by the
`CONCURRENCY_LIMIT_MANIFEST_ENTRIES` constant, which I'm happy to adjust in
this PR to suit
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org
For additional commands, e-mail: issues-h...@iceberg.apache.org
