let mut res: Result<()> = Ok(());
    let mut batch_size_partition_iter = partition.iter() 
        .map(|partitioned_file|{
            let mut num_rows: usize = match object_store.file_reader(partitioned_file.file_meta.sized_file.clone()){
                Ok(object_reader) => {
                    match SerializedFileReader::new(ChunkObjectReader(object_reader)){
                        Ok(file_reader) => {
                            file_reader
                                .metadata()
                                .file_metadata()
                                .num_rows()
                                .try_into()
                                .expect("Row count should always be greater than or equal to 0 and less than usize::MAX")
                        },
                        Err(e) =>{
                            res = Err(e.into());
                            0
                        },
                    }
                },
                Err(e) => {
                    res = Err(e);
                    0
                },
            };            
            num_rows = limit.min(num_rows); 
            limit -= num_rows;
            (num_rows, partitioned_file.partition_values.as_slice())
        })
        .take_while(|(num_rows, _)| *num_rows != 0)
        .flat_map(|(num_rows, partition_values)| BatchSizeIter::new(num_rows, batch_size).zip(std::iter::repeat(partition_values)));
        Iterator::try_for_each(&mut batch_size_partition_iter,|(batch_size, partition_values)| {
            send_result(&response_tx, partition_column_projector.project_empty(batch_size, partition_values))
        })?;
        res?;
        Ok(())