pub async fn execute_stream_partitioned(
        &self,
        physical_plan: Arc<dyn ExecutionPlan>,
        partition: usize,
    ) -> Result<SendableRecordBatchStream> {
        let span = self
            .recorder
            .span()
            .map(|span| span.child("execute_stream_partitioned"));

        // TODO add a nice accessor to the Runtime from the execution context
        let runtime = Arc::clone(&self.inner.state.lock().unwrap().runtime_env);

        self.run(async move {
            let stream = physical_plan.execute(partition, runtime).await?;
            let stream = TracedStream::new(stream, span, physical_plan);
            Ok(Box::pin(stream) as _)
        })
        .await
    }
/// Executes a single partition of a physical plan and produces a
/// `SendableRecordBatchStream` to stream over the result that
/// iterates over the results. The creation of the stream is
/// performed in a separate thread pool.
Executes a single partition of a physical plan and produces a
`SendableRecordBatchStream` to stream over the result that
iterates over the results. The creation of the stream is
performed in a separate thread pool.
Executes a single partition of a physical plan and produces a ` SendableRecordBatchStream ` to stream over the result that iterates over the results . The creation of the stream is performed in a separate thread pool .
pub async fn execute_stream_partitioned(
        &self,
        physical_plan: Arc<dyn ExecutionPlan>,
        partition: usize,
    ) -> Result<SendableRecordBatchStream> {
        let span = self
            .recorder
            .span()
            .map(|span| span.child("execute_stream_partitioned"));
        // TODO add a nice accessor to the Runtime from the execution context
        let runtime = Arc::clone(&self.inner.state.lock().unwrap().runtime_env);
        self.run(async move {
            let stream = physical_plan.execute(partition, runtime).await?;
            let stream = TracedStream::new(stream, span, physical_plan);
            Ok(Box::pin(stream) as _)
        })
        .await
    }
pub async fn execute_stream_partitioned ( & self , physical_plan : Arc < dyn ExecutionPlan > , partition : usize , ) -> Result < SendableRecordBatchStream > { let span = self . recorder . span ( ) . map ( | span | span . child ( " " ) ) ; // TODO add a nice accessor to the Runtime from the execution context let runtime = Arc :: clone ( & self . inner . state . lock ( ) . unwrap ( ) . runtime_env ) ; self . run ( async move { let stream = physical_plan . execute ( partition , runtime ) . await ? ; let stream = TracedStream :: new ( stream , span , physical_plan ) ; Ok ( Box :: pin ( stream ) as _ ) } ) . await }
Executes a single partition of a physical plan and produces a
`SendableRecordBatchStream` to stream over the result that
iterates over the results.
Executes a single partition of a physical plan and produces a ` SendableRecordBatchStream ` to stream over the result that iterates over the results .
&self
physical_plan
Arc<dyn ExecutionPlan>
partition
usize
&self
physical_plan
Arc<dyn ExecutionPlan>
partition
usize