Method create_external_table

datafusion/core/src/execution/context/mod.rs:818–866

(
        &self,
        cmd: &CreateExternalTable,
    )

    }

    async fn create_external_table(
        &self,
        cmd: &CreateExternalTable,
    ) -> Result<DataFrame> {
        let exist = self.table_exist(cmd.name.clone())?;

        if cmd.temporary {
            return not_impl_err!("Temporary tables not supported");
        }

        match (cmd.if_not_exists, cmd.or_replace, exist) {
            (true, false, true) => self.return_empty_dataframe(),
            (false, true, true) => {
                let result = self
                    .find_and_deregister(cmd.name.clone(), TableType::Base)
                    .await;

                match result {
                    Ok(true) => {
                        let table_provider: Arc<dyn TableProvider> =
                            self.create_custom_table(cmd).await?;
                        self.register_table(cmd.name.clone(), table_provider)?;
                        self.return_empty_dataframe()
                    }
                    Ok(false) => {
                        let table_provider: Arc<dyn TableProvider> =
                            self.create_custom_table(cmd).await?;
                        self.register_table(cmd.name.clone(), table_provider)?;
                        self.return_empty_dataframe()
                    }
                    Err(e) => {
                        exec_err!("Errored while deregistering external table: {}", e)
                    }
                }
            }
            (true, true, true) => {
                exec_err!("'IF NOT EXISTS' cannot coexist with 'REPLACE'")
            }
            (_, _, false) => {
                let table_provider: Arc<dyn TableProvider> =
                    self.create_custom_table(cmd).await?;
                self.register_table(cmd.name.clone(), table_provider)?;
                self.return_empty_dataframe()
            }
            (false, false, true) => {
                exec_err!("External table '{}' already exists", cmd.name)
            }
        }
    }

    async fn create_memory_table(&self, cmd: CreateMemoryTable) -> Result<DataFrame> {
        let CreateMemoryTable {