Merge branch 'dev' into replace-arrow2

src/query/Cargo.toml

@@ -25,6 +25,7 @@ metrics = "0.20"
 once_cell = "1.10"
 serde = "1.0"
 serde_json = "1.0"
+session = { path = "../session" }
 snafu = { version = "0.7", features = ["backtraces"] }
 sql = { path = "../sql" }
 table = { path = "../table" }

src/query/src/datafusion.rs

@@ -32,6 +32,7 @@ use common_recordbatch::{EmptyRecordBatchStream, SendableRecordBatchStream};
 use common_telemetry::timer;
 use datafusion::physical_plan::coalesce_partitions::CoalescePartitionsExec;
 use datafusion::physical_plan::ExecutionPlan;
+use session::context::QueryContextRef;
 use snafu::{OptionExt, ResultExt};
 use sql::dialect::GenericDialect;
 use sql::parser::ParserContext;
@@ -46,7 +47,7 @@ use crate::physical_optimizer::PhysicalOptimizer;
 use crate::physical_planner::PhysicalPlanner;
 use crate::plan::LogicalPlan;
 use crate::planner::Planner;
-use crate::query_engine::{QueryContext, QueryEngineState};
+use crate::query_engine::{QueryEngineContext, QueryEngineState};
 use crate::{metric, QueryEngine};
 
 pub(crate) struct DatafusionQueryEngine {
@@ -61,6 +62,7 @@ impl DatafusionQueryEngine {
     }
 }
 
+// TODO(LFC): Refactor consideration: extract a "Planner" that stores query context and execute queries inside.
 #[async_trait::async_trait]
 impl QueryEngine for DatafusionQueryEngine {
     fn name(&self) -> &str {
@@ -75,21 +77,25 @@ impl QueryEngine for DatafusionQueryEngine {
         Ok(statement.remove(0))
     }
 
-    fn statement_to_plan(&self, stmt: Statement) -> Result<LogicalPlan> {
-        let context_provider = DfContextProviderAdapter::new(self.state.clone());
+    fn statement_to_plan(
+        &self,
+        stmt: Statement,
+        query_ctx: QueryContextRef,
+    ) -> Result<LogicalPlan> {
+        let context_provider = DfContextProviderAdapter::new(self.state.clone(), query_ctx);
         let planner = DfPlanner::new(&context_provider);
 
         planner.statement_to_plan(stmt)
     }
 
-    fn sql_to_plan(&self, sql: &str) -> Result<LogicalPlan> {
+    fn sql_to_plan(&self, sql: &str, query_ctx: QueryContextRef) -> Result<LogicalPlan> {
         let _timer = timer!(metric::METRIC_PARSE_SQL_ELAPSED);
         let stmt = self.sql_to_statement(sql)?;
-        self.statement_to_plan(stmt)
+        self.statement_to_plan(stmt, query_ctx)
     }
 
     async fn execute(&self, plan: &LogicalPlan) -> Result<Output> {
-        let mut ctx = QueryContext::new(self.state.clone());
+        let mut ctx = QueryEngineContext::new(self.state.clone());
         let logical_plan = self.optimize_logical_plan(&mut ctx, plan)?;
         let physical_plan = self.create_physical_plan(&mut ctx, &logical_plan).await?;
         let physical_plan = self.optimize_physical_plan(&mut ctx, physical_plan)?;
@@ -100,7 +106,7 @@ impl QueryEngine for DatafusionQueryEngine {
     }
 
     async fn execute_physical(&self, plan: &Arc<dyn PhysicalPlan>) -> Result<Output> {
-        let ctx = QueryContext::new(self.state.clone());
+        let ctx = QueryEngineContext::new(self.state.clone());
         Ok(Output::Stream(self.execute_stream(&ctx, plan).await?))
     }
 
@@ -127,7 +133,7 @@ impl QueryEngine for DatafusionQueryEngine {
 impl LogicalOptimizer for DatafusionQueryEngine {
     fn optimize_logical_plan(
         &self,
-        _ctx: &mut QueryContext,
+        _: &mut QueryEngineContext,
         plan: &LogicalPlan,
     ) -> Result<LogicalPlan> {
         let _timer = timer!(metric::METRIC_OPTIMIZE_LOGICAL_ELAPSED);
@@ -151,7 +157,7 @@ impl LogicalOptimizer for DatafusionQueryEngine {
 impl PhysicalPlanner for DatafusionQueryEngine {
     async fn create_physical_plan(
         &self,
-        _ctx: &mut QueryContext,
+        _: &mut QueryEngineContext,
         logical_plan: &LogicalPlan,
     ) -> Result<Arc<dyn PhysicalPlan>> {
         let _timer = timer!(metric::METRIC_CREATE_PHYSICAL_ELAPSED);
@@ -183,7 +189,7 @@ impl PhysicalPlanner for DatafusionQueryEngine {
 impl PhysicalOptimizer for DatafusionQueryEngine {
     fn optimize_physical_plan(
         &self,
-        _ctx: &mut QueryContext,
+        _: &mut QueryEngineContext,
         plan: Arc<dyn PhysicalPlan>,
     ) -> Result<Arc<dyn PhysicalPlan>> {
         let _timer = timer!(metric::METRIC_OPTIMIZE_PHYSICAL_ELAPSED);
@@ -211,7 +217,7 @@ impl PhysicalOptimizer for DatafusionQueryEngine {
 impl QueryExecutor for DatafusionQueryEngine {
     async fn execute_stream(
         &self,
-        ctx: &QueryContext,
+        ctx: &QueryEngineContext,
         plan: &Arc<dyn PhysicalPlan>,
     ) -> Result<SendableRecordBatchStream> {
         let _timer = timer!(metric::METRIC_EXEC_PLAN_ELAPSED);
@@ -250,6 +256,7 @@ mod tests {
     use common_recordbatch::util;
     use datafusion::field_util::{FieldExt, SchemaExt};
     use datatypes::arrow::array::UInt64Array;
+    use session::context::QueryContext;
     use table::table::numbers::NumbersTable;
 
     use crate::query_engine::{QueryEngineFactory, QueryEngineRef};
@@ -277,7 +284,9 @@ mod tests {
         let engine = create_test_engine();
         let sql = "select sum(number) from numbers limit 20";
 
-        let plan = engine.sql_to_plan(sql).unwrap();
+        let plan = engine
+            .sql_to_plan(sql, Arc::new(QueryContext::new()))
+            .unwrap();
 
         assert_eq!(
             format!("{:?}", plan),
@@ -293,7 +302,9 @@ mod tests {
         let engine = create_test_engine();
         let sql = "select sum(number) from numbers limit 20";
 
-        let plan = engine.sql_to_plan(sql).unwrap();
+        let plan = engine
+            .sql_to_plan(sql, Arc::new(QueryContext::new()))
+            .unwrap();
         let output = engine.execute(&plan).await.unwrap();
 
         match output {

src/query/src/datafusion/planner.rs

@@ -21,7 +21,9 @@ use datafusion::physical_plan::udaf::AggregateUDF;
 use datafusion::physical_plan::udf::ScalarUDF;
 use datafusion::sql::planner::{ContextProvider, SqlToRel};
 use datatypes::arrow::datatypes::DataType;
+use session::context::QueryContextRef;
 use snafu::ResultExt;
+use sql::statements::explain::Explain;
 use sql::statements::query::Query;
 use sql::statements::statement::Statement;
 
@@ -53,6 +55,18 @@ impl<'a, S: ContextProvider + Send + Sync> DfPlanner<'a, S> {
 
         Ok(LogicalPlan::DfPlan(result))
     }
+
+    /// Converts EXPLAIN statement to logical plan.
+    pub fn explain_to_plan(&self, explain: Explain) -> Result<LogicalPlan> {
+        let result = self
+            .sql_to_rel
+            .sql_statement_to_plan(explain.inner.clone())
+            .context(error::PlanSqlSnafu {
+                sql: explain.to_string(),
+            })?;
+
+        Ok(LogicalPlan::DfPlan(result))
+    }
 }
 
 impl<'a, S> Planner for DfPlanner<'a, S>
@@ -63,6 +77,7 @@ where
     fn statement_to_plan(&self, statement: Statement) -> Result<LogicalPlan> {
         match statement {
             Statement::Query(qb) => self.query_to_plan(qb),
+            Statement::Explain(explain) => self.explain_to_plan(explain),
             Statement::ShowTables(_)
             | Statement::ShowDatabases(_)
             | Statement::ShowCreateTable(_)
@@ -70,18 +85,21 @@ where
             | Statement::CreateTable(_)
             | Statement::CreateDatabase(_)
             | Statement::Alter(_)
-            | Statement::Insert(_) => unreachable!(),
+            | Statement::Insert(_)
+            | Statement::DropTable(_)
+            | Statement::Use(_) => unreachable!(),
         }
     }
 }
 
 pub(crate) struct DfContextProviderAdapter {
     state: QueryEngineState,
+    query_ctx: QueryContextRef,
 }
 
 impl DfContextProviderAdapter {
-    pub(crate) fn new(state: QueryEngineState) -> Self {
-        Self { state }
+    pub(crate) fn new(state: QueryEngineState, query_ctx: QueryContextRef) -> Self {
+        Self { state, query_ctx }
     }
 }
 
@@ -89,11 +107,18 @@ impl DfContextProviderAdapter {
 ///                           manage UDFs, UDAFs, variables by ourself in future.
 impl ContextProvider for DfContextProviderAdapter {
     fn get_table_provider(&self, name: TableReference) -> Option<Arc<dyn TableProvider>> {
-        self.state
-            .df_context()
-            .state
-            .lock()
-            .get_table_provider(name)
+        let schema = self.query_ctx.current_schema();
+        let execution_ctx = self.state.df_context().state.lock();
+        match name {
+            TableReference::Bare { table } if schema.is_some() => {
+                execution_ctx.get_table_provider(TableReference::Partial {
+                    // unwrap safety: checked in this match's arm
+                    schema: &schema.unwrap(),
+                    table,
+                })
+            }
+            _ => execution_ctx.get_table_provider(name),
+        }
     }
 
     fn get_function_meta(&self, name: &str) -> Option<Arc<ScalarUDF>> {

src/query/src/executor.rs

@@ -18,14 +18,14 @@ use common_query::physical_plan::PhysicalPlan;
 use common_recordbatch::SendableRecordBatchStream;
 
 use crate::error::Result;
-use crate::query_engine::QueryContext;
+use crate::query_engine::QueryEngineContext;
 
 /// Executor to run [ExecutionPlan].
 #[async_trait::async_trait]
 pub trait QueryExecutor {
     async fn execute_stream(
         &self,
-        ctx: &QueryContext,
+        ctx: &QueryEngineContext,
         plan: &Arc<dyn PhysicalPlan>,
     ) -> Result<SendableRecordBatchStream>;
 }

src/query/src/lib.rs

@@ -26,4 +26,6 @@ pub mod planner;
 pub mod query_engine;
 pub mod sql;
 
-pub use crate::query_engine::{QueryContext, QueryEngine, QueryEngineFactory, QueryEngineRef};
+pub use crate::query_engine::{
+    QueryEngine, QueryEngineContext, QueryEngineFactory, QueryEngineRef,
+};

src/query/src/logical_optimizer.rs

@@ -14,12 +14,12 @@
 
 use crate::error::Result;
 use crate::plan::LogicalPlan;
-use crate::query_engine::QueryContext;
+use crate::query_engine::QueryEngineContext;
 
 pub trait LogicalOptimizer {
     fn optimize_logical_plan(
         &self,
-        ctx: &mut QueryContext,
+        ctx: &mut QueryEngineContext,
         plan: &LogicalPlan,
     ) -> Result<LogicalPlan>;
 }

src/query/src/physical_optimizer.rs

@@ -17,12 +17,12 @@ use std::sync::Arc;
 use common_query::physical_plan::PhysicalPlan;
 
 use crate::error::Result;
-use crate::query_engine::QueryContext;
+use crate::query_engine::QueryEngineContext;
 
 pub trait PhysicalOptimizer {
     fn optimize_physical_plan(
         &self,
-        ctx: &mut QueryContext,
+        ctx: &mut QueryEngineContext,
         plan: Arc<dyn PhysicalPlan>,
     ) -> Result<Arc<dyn PhysicalPlan>>;
 }

src/query/src/physical_planner.rs

@@ -18,7 +18,7 @@ use common_query::physical_plan::PhysicalPlan;
 
 use crate::error::Result;
 use crate::plan::LogicalPlan;
-use crate::query_engine::QueryContext;
+use crate::query_engine::QueryEngineContext;
 
 /// Physical query planner that converts a `LogicalPlan` to an
 /// `ExecutionPlan` suitable for execution.
@@ -27,7 +27,7 @@ pub trait PhysicalPlanner {
     /// Create a physical plan from a logical plan
     async fn create_physical_plan(
         &self,
-        ctx: &mut QueryContext,
+        ctx: &mut QueryEngineContext,
         logical_plan: &LogicalPlan,
     ) -> Result<Arc<dyn PhysicalPlan>>;
 }

src/query/src/query_engine.rs

@@ -23,12 +23,13 @@ use common_function::scalars::{FunctionRef, FUNCTION_REGISTRY};
 use common_query::physical_plan::PhysicalPlan;
 use common_query::prelude::ScalarUdf;
 use common_query::Output;
+use session::context::QueryContextRef;
 use sql::statements::statement::Statement;
 
 use crate::datafusion::DatafusionQueryEngine;
 use crate::error::Result;
 use crate::plan::LogicalPlan;
-pub use crate::query_engine::context::QueryContext;
+pub use crate::query_engine::context::QueryEngineContext;
 pub use crate::query_engine::state::QueryEngineState;
 
 #[async_trait::async_trait]
@@ -37,9 +38,10 @@ pub trait QueryEngine: Send + Sync {
 
     fn sql_to_statement(&self, sql: &str) -> Result<Statement>;
 
-    fn statement_to_plan(&self, stmt: Statement) -> Result<LogicalPlan>;
+    fn statement_to_plan(&self, stmt: Statement, query_ctx: QueryContextRef)
+        -> Result<LogicalPlan>;
 
-    fn sql_to_plan(&self, sql: &str) -> Result<LogicalPlan>;
+    fn sql_to_plan(&self, sql: &str, query_ctx: QueryContextRef) -> Result<LogicalPlan>;
 
     async fn execute(&self, plan: &LogicalPlan) -> Result<Output>;
 

src/query/src/query_engine/context.rs

@@ -16,11 +16,11 @@
 use crate::query_engine::state::QueryEngineState;
 
 #[derive(Debug)]
-pub struct QueryContext {
+pub struct QueryEngineContext {
     state: QueryEngineState,
 }
 
-impl QueryContext {
+impl QueryEngineContext {
     pub fn new(state: QueryEngineState) -> Self {
         Self { state }
     }

src/query/src/sql.rs

@@ -22,11 +22,15 @@ use datatypes::prelude::*;
 use datatypes::schema::{ColumnSchema, Schema};
 use datatypes::vectors::{Helper, StringVector};
 use once_cell::sync::Lazy;
+use session::context::QueryContextRef;
 use snafu::{ensure, OptionExt, ResultExt};
 use sql::statements::describe::DescribeTable;
+use sql::statements::explain::Explain;
 use sql::statements::show::{ShowDatabases, ShowKind, ShowTables};
+use sql::statements::statement::Statement;
 
 use crate::error::{self, Result};
+use crate::QueryEngineRef;
 
 const SCHEMAS_COLUMN: &str = "Schemas";
 const TABLES_COLUMN: &str = "Tables";
@@ -106,7 +110,11 @@ pub fn show_databases(stmt: ShowDatabases, catalog_manager: CatalogManagerRef) -
     Ok(Output::RecordBatches(records))
 }
 
-pub fn show_tables(stmt: ShowTables, catalog_manager: CatalogManagerRef) -> Result<Output> {
+pub fn show_tables(
+    stmt: ShowTables,
+    catalog_manager: CatalogManagerRef,
+    query_ctx: QueryContextRef,
+) -> Result<Output> {
     // TODO(LFC): supports WHERE
     ensure!(
         matches!(stmt.kind, ShowKind::All | ShowKind::Like(_)),
@@ -115,9 +123,15 @@ pub fn show_tables(stmt: ShowTables, catalog_manager: CatalogManagerRef) -> Resu
         }
     );
 
-    let schema = stmt.database.as_deref().unwrap_or(DEFAULT_SCHEMA_NAME);
+    let schema = if let Some(database) = stmt.database {
+        database
+    } else {
+        query_ctx
+            .current_schema()
+            .unwrap_or_else(|| DEFAULT_SCHEMA_NAME.to_string())
+    };
     let schema = catalog_manager
-        .schema(DEFAULT_CATALOG_NAME, schema)
+        .schema(DEFAULT_CATALOG_NAME, &schema)
         .context(error::CatalogSnafu)?
         .context(error::SchemaNotFoundSnafu { schema })?;
     let tables = schema.table_names().context(error::CatalogSnafu)?;
@@ -138,6 +152,15 @@ pub fn show_tables(stmt: ShowTables, catalog_manager: CatalogManagerRef) -> Resu
     Ok(Output::RecordBatches(records))
 }
 
+pub async fn explain(
+    stmt: Box<Explain>,
+    query_engine: QueryEngineRef,
+    query_ctx: QueryContextRef,
+) -> Result<Output> {
+    let plan = query_engine.statement_to_plan(Statement::Explain(*stmt), query_ctx)?;
+    query_engine.execute(&plan).await
+}
+
 pub fn describe_table(stmt: DescribeTable, catalog_manager: CatalogManagerRef) -> Result<Output> {
     let catalog = stmt.catalog_name.as_str();
     let schema = stmt.schema_name.as_str();

src/query/tests/argmax_test.rs

@@ -24,6 +24,7 @@ use datatypes::types::PrimitiveElement;
 use function::{create_query_engine, get_numbers_from_table};
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 
 #[tokio::test]
 async fn test_argmax_aggregator() -> Result<()> {
@@ -95,7 +96,9 @@ async fn execute_argmax<'a>(
         "select ARGMAX({}) as argmax from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/argmin_test.rs

@@ -25,6 +25,7 @@ use datatypes::types::PrimitiveElement;
 use function::{create_query_engine, get_numbers_from_table};
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 
 #[tokio::test]
 async fn test_argmin_aggregator() -> Result<()> {
@@ -96,7 +97,9 @@ async fn execute_argmin<'a>(
         "select argmin({}) as argmin from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/function.rs

@@ -27,6 +27,7 @@ use datatypes::vectors::PrimitiveVector;
 use query::query_engine::QueryEngineFactory;
 use query::QueryEngine;
 use rand::Rng;
+use session::context::QueryContext;
 use table::test_util::MemTable;
 
 pub fn create_query_engine() -> Arc<dyn QueryEngine> {
@@ -80,7 +81,9 @@ where
     for<'a> T: Scalar<RefType<'a> = T>,
 {
     let sql = format!("SELECT {} FROM {}", column_name, table_name);
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/mean_test.rs

@@ -28,6 +28,7 @@ use function::{create_query_engine, get_numbers_from_table};
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 
 #[tokio::test]
 async fn test_mean_aggregator() -> Result<()> {
@@ -89,7 +90,9 @@ async fn execute_mean<'a>(
     engine: Arc<dyn QueryEngine>,
 ) -> RecordResult<Vec<RecordBatch>> {
     let sql = format!("select MEAN({}) as mean from {}", column_name, table_name);
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/my_sum_udaf_example.rs

@@ -36,6 +36,7 @@ use datatypes::with_match_primitive_type_id;
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::QueryEngineFactory;
+use session::context::QueryContext;
 use table::test_util::MemTable;
 
 #[derive(Debug, Default)]
@@ -228,7 +229,7 @@ where
         "select MY_SUM({}) as my_sum from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql)?;
+    let plan = engine.sql_to_plan(&sql, Arc::new(QueryContext::new()))?;
 
     let output = engine.execute(&plan).await?;
     let recordbatch_stream = match output {

src/query/tests/percentile_test.rs

@@ -30,6 +30,7 @@ use function::{create_query_engine, get_numbers_from_table};
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::{QueryEngine, QueryEngineFactory};
+use session::context::QueryContext;
 use table::test_util::MemTable;
 
 #[tokio::test]
@@ -53,7 +54,9 @@ async fn test_percentile_aggregator() -> Result<()> {
 async fn test_percentile_correctness() -> Result<()> {
     let engine = create_correctness_engine();
     let sql = String::from("select PERCENTILE(corr_number,88.0) as percentile from corr_numbers");
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {
@@ -113,7 +116,9 @@ async fn execute_percentile<'a>(
         "select PERCENTILE({},50.0) as percentile from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/polyval_test.rs

@@ -26,6 +26,7 @@ use function::{create_query_engine, get_numbers_from_table};
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 
 #[tokio::test]
 async fn test_polyval_aggregator() -> Result<()> {
@@ -92,7 +93,9 @@ async fn execute_polyval<'a>(
         "select POLYVAL({}, 0) as polyval from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/query_engine_test.rs

@@ -37,6 +37,7 @@ use query::plan::LogicalPlan;
 use query::query_engine::QueryEngineFactory;
 use query::QueryEngine;
 use rand::Rng;
+use session::context::QueryContext;
 use table::table::adapter::DfTableProviderAdapter;
 use table::table::numbers::NumbersTable;
 use table::test_util::MemTable;
@@ -134,7 +135,10 @@ async fn test_udf() -> Result<()> {
 
     engine.register_udf(udf);
 
-    let plan = engine.sql_to_plan("select pow(number, number) as p from numbers limit 10")?;
+    let plan = engine.sql_to_plan(
+        "select pow(number, number) as p from numbers limit 10",
+        Arc::new(QueryContext::new()),
+    )?;
 
     let output = engine.execute(&plan).await?;
     let recordbatch = match output {
@@ -242,7 +246,9 @@ where
     for<'a> T: Scalar<RefType<'a> = T>,
 {
     let sql = format!("SELECT {} FROM {}", column_name, table_name);
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {
@@ -330,7 +336,9 @@ async fn execute_median<'a>(
         "select MEDIAN({}) as median from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/scipy_stats_norm_cdf_test.rs

@@ -26,6 +26,7 @@ use function::{create_query_engine, get_numbers_from_table};
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 use statrs::distribution::{ContinuousCDF, Normal};
 use statrs::statistics::Statistics;
 
@@ -94,7 +95,9 @@ async fn execute_scipy_stats_norm_cdf<'a>(
         "select SCIPYSTATSNORMCDF({},2.0) as scipy_stats_norm_cdf from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {

src/query/tests/scipy_stats_norm_pdf.rs

@@ -26,6 +26,7 @@ use function::{create_query_engine, get_numbers_from_table};
 use num_traits::AsPrimitive;
 use query::error::Result;
 use query::QueryEngine;
+use session::context::QueryContext;
 use statrs::distribution::{Continuous, Normal};
 use statrs::statistics::Statistics;
 
@@ -94,7 +95,9 @@ async fn execute_scipy_stats_norm_pdf<'a>(
         "select SCIPYSTATSNORMPDF({},2.0) as scipy_stats_norm_pdf from {}",
         column_name, table_name
     );
-    let plan = engine.sql_to_plan(&sql).unwrap();
+    let plan = engine
+        .sql_to_plan(&sql, Arc::new(QueryContext::new()))
+        .unwrap();
 
     let output = engine.execute(&plan).await.unwrap();
     let recordbatch_stream = match output {