Method execute_logical_plan

datafusion/core/src/execution/context/mod.rs:686–775

Execute the [`LogicalPlan`], return a [`DataFrame`]. This API is not featured limited (so all SQL such as `CREATE TABLE` and `COPY` will be run). If you wish to limit the type of plan that can be run from SQL, see [`Self::sql_with_options`] and [`SQLOptions::verify_plan`].

(&self, plan: LogicalPlan)

    /// SQL, see [`Self::sql_with_options`] and
    /// [`SQLOptions::verify_plan`].
    pub async fn execute_logical_plan(&self, plan: LogicalPlan) -> Result<DataFrame> {
        match plan {
            LogicalPlan::Ddl(ddl) => {
                // Box::pin avoids allocating the stack space within this function's frame
                // for every one of these individual async functions, decreasing the risk of
                // stack overflows.
                match ddl {
                    DdlStatement::CreateExternalTable(cmd) => {
                        (Box::pin(async move { self.create_external_table(&cmd).await })
                            as std::pin::Pin<Box<dyn Future<Output = _> + Send>>)
                            .await
                    }
                    DdlStatement::CreateMemoryTable(cmd) => {
                        Box::pin(self.create_memory_table(cmd)).await
                    }
                    DdlStatement::CreateView(cmd) => {
                        Box::pin(self.create_view(cmd)).await
                    }
                    DdlStatement::CreateCatalogSchema(cmd) => {
                        Box::pin(self.create_catalog_schema(cmd)).await
                    }
                    DdlStatement::CreateCatalog(cmd) => {
                        Box::pin(self.create_catalog(cmd)).await
                    }
                    DdlStatement::DropTable(cmd) => Box::pin(self.drop_table(cmd)).await,
                    DdlStatement::DropView(cmd) => Box::pin(self.drop_view(cmd)).await,
                    DdlStatement::DropCatalogSchema(cmd) => {
                        Box::pin(self.drop_schema(cmd)).await
                    }
                    DdlStatement::CreateFunction(cmd) => {
                        Box::pin(self.create_function(cmd)).await
                    }
                    DdlStatement::DropFunction(cmd) => {
                        Box::pin(self.drop_function(cmd)).await
                    }
                    ddl => Ok(DataFrame::new(self.state(), LogicalPlan::Ddl(ddl))),
                }
            }
            // TODO what about the other statements (like TransactionStart and TransactionEnd)
            LogicalPlan::Statement(Statement::SetVariable(stmt)) => {
                self.set_variable(stmt).await?;
                self.return_empty_dataframe()
            }
            LogicalPlan::Statement(Statement::ResetVariable(stmt)) => {
                self.reset_variable(stmt).await?;
                self.return_empty_dataframe()
            }
            LogicalPlan::Statement(Statement::Prepare(Prepare {
                name,
                input,
                fields,
            })) => {
                // The number of parameters must match the specified data types length.
                if !fields.is_empty() {
                    let param_names = input.get_parameter_names()?;
                    if param_names.len() != fields.len() {
                        return plan_err!(
                            "Prepare specifies {} data types but query has {} parameters",