Apache DataFusion SQL Query Engine
feat: add RESET statement for configuration variabless (#18408)
Alex Huang71fcd03d614c
diff --git a/datafusion/common/src/config.rs b/datafusion/common/src/config.rsindex 190ebf05bd..212db653f7 100644--- a/datafusion/common/src/config.rs+++ b/datafusion/common/src/config.rs@@ -185,6 +185,31 @@ macro_rules! config_namespace {self.$field_name.visit(v, key.as_str(), desc);)*}++ fn reset(&mut self, key: &str) -> $crate::error::Result<()> {+ let (key, rem) = key.split_once('.').unwrap_or((key, ""));+ match key {+ $(+ stringify!($field_name) => {+ #[allow(deprecated)]+ {+ if rem.is_empty() {+ let default_value: $field_type = $default;+ self.$field_name = default_value;+ Ok(())+ } else {+ self.$field_name.reset(rem)+ }+ }+ },+ )*+ _ => $crate::error::_config_err!(+ "Config value \"{}\" not found on {}",+ key,+ stringify!($struct_name)+ ),+ }+ }}impl Default for $struct_name {fn default() -> Self {@@ -1169,6 +1194,45 @@ impl ConfigField for ConfigOptions {_ => _config_err!("Config value \"{key}\" not found on ConfigOptions"),}}++ /// Reset a configuration option back to its default value+ fn reset(&mut self, key: &str) -> Result<()> {+ let Some((prefix, rest)) = key.split_once('.') else {+ return _config_err!("could not find config namespace for key \"{key}\"");+ };++ if prefix != "datafusion" {+ return _config_err!("Could not find config namespace \"{prefix}\"");+ }++ let (section, rem) = rest.split_once('.').unwrap_or((rest, ""));+ if rem.is_empty() {+ return _config_err!("could not find config field for key \"{key}\"");+ }++ match section {+ "catalog" => self.catalog.reset(rem),+ "execution" => self.execution.reset(rem),+ "optimizer" => {+ if rem == "enable_dynamic_filter_pushdown" {+ let defaults = OptimizerOptions::default();+ self.optimizer.enable_dynamic_filter_pushdown =+ defaults.enable_dynamic_filter_pushdown;+ self.optimizer.enable_topk_dynamic_filter_pushdown =+ defaults.enable_topk_dynamic_filter_pushdown;+ self.optimizer.enable_join_dynamic_filter_pushdown =+ defaults.enable_join_dynamic_filter_pushdown;+ Ok(())+ } else {+ self.optimizer.reset(rem)+ }+ }+ "explain" => self.explain.reset(rem),+ "sql_parser" => self.sql_parser.reset(rem),+ "format" => self.format.reset(rem),+ other => _config_err!("Config value \"{other}\" not found on ConfigOptions"),+ }+ }}impl ConfigOptions {@@ -1477,6 +1541,10 @@ pub trait ConfigField {fn visit<V: Visit>(&self, v: &mut V, key: &str, description: &'static str);fn set(&mut self, key: &str, value: &str) -> Result<()>;++ fn reset(&mut self, key: &str) -> Result<()> {+ _config_err!("Reset is not supported for this config field, key: {}", key)+ }}impl<F: ConfigField + Default> ConfigField for Option<F> {@@ -1490,6 +1558,15 @@ impl<F: ConfigField + Default> ConfigField for Option<F> {fn set(&mut self, key: &str, value: &str) -> Result<()> {self.get_or_insert_with(Default::default).set(key, value)}++ fn reset(&mut self, key: &str) -> Result<()> {+ if key.is_empty() {+ *self = Default::default();+ Ok(())+ } else {+ self.get_or_insert_with(Default::default).reset(key)+ }+ }}/// Default transformation to parse a [`ConfigField`] for a string.@@ -1554,6 +1631,19 @@ macro_rules! config_field {*self = $transform;Ok(())}++ fn reset(&mut self, key: &str) -> $crate::error::Result<()> {+ if key.is_empty() {+ *self = <$t as Default>::default();+ Ok(())+ } else {+ $crate::error::_config_err!(+ "Config field is a scalar {} and does not have nested field \"{}\"",+ stringify!($t),+ key+ )+ }+ }}};}@@ -2562,7 +2652,7 @@ impl ConfigField for ConfigFileDecryptionProperties {self.footer_signature_verification.set(rem, value.as_ref())}_ => _config_err!(- "Config value \"{}\" not found on ConfigFileEncryptionProperties",+ "Config value \"{}\" not found on ConfigFileDecryptionProperties",key),}@@ -2876,7 +2966,6 @@ mod tests {};use std::any::Any;use std::collections::HashMap;- use std::sync::Arc;#[derive(Default, Debug, Clone)]pub struct TestExtensionConfig {@@ -2991,6 +3080,19 @@ mod tests {assert_eq!(COUNT.load(std::sync::atomic::Ordering::Relaxed), 1);}+ #[test]+ fn reset_nested_scalar_reports_helpful_error() {+ let mut value = true;+ let err = <bool as ConfigField>::reset(&mut value, "nested").unwrap_err();+ let message = err.to_string();+ assert!(+ message.starts_with(+ "Invalid or Unsupported Configuration: Config field is a scalar bool and does not have nested field \"nested\""+ ),+ "unexpected error message: {message}"+ );+ }+#[cfg(feature = "parquet")]#[test]fn parquet_table_options() {@@ -3013,6 +3115,7 @@ mod tests {};use parquet::encryption::decrypt::FileDecryptionProperties;use parquet::encryption::encrypt::FileEncryptionProperties;+ use std::sync::Arc;let footer_key = b"0123456789012345".to_vec(); // 128bit/16let column_names = vec!["double_field", "float_field"];diff --git a/datafusion/core/src/execution/context/mod.rs b/datafusion/core/src/execution/context/mod.rsindex bca4cce9ba..9c7339e674 100644--- a/datafusion/core/src/execution/context/mod.rs+++ b/datafusion/core/src/execution/context/mod.rs@@ -45,8 +45,8 @@ use crate::{logical_expr::{CreateCatalog, CreateCatalogSchema, CreateExternalTable, CreateFunction,CreateMemoryTable, CreateView, DropCatalogSchema, DropFunction, DropTable,- DropView, Execute, LogicalPlan, LogicalPlanBuilder, Prepare, SetVariable,- TableType, UNNAMED_TABLE,+ DropView, Execute, LogicalPlan, LogicalPlanBuilder, Prepare, ResetVariable,+ SetVariable, TableType, UNNAMED_TABLE,},physical_expr::PhysicalExpr,physical_plan::ExecutionPlan,@@ -63,7 +63,7 @@ use datafusion_catalog::MemoryCatalogProvider;use datafusion_catalog::{DynamicFileCatalog, TableFunction, TableFunctionImpl, UrlTableFactory,};-use datafusion_common::config::ConfigOptions;+use datafusion_common::config::{ConfigField, ConfigOptions};use datafusion_common::metadata::ScalarAndMetadata;use datafusion_common::{config::{ConfigExtension, TableOptions},@@ -72,7 +72,11 @@ use datafusion_common::{tree_node::{TreeNodeRecursion, TreeNodeVisitor},DFSchema, DataFusionError, ParamValues, SchemaReference, TableReference,};+use datafusion_execution::cache::cache_manager::DEFAULT_METADATA_CACHE_LIMIT;pub use datafusion_execution::config::SessionConfig;+use datafusion_execution::disk_manager::{+ DiskManagerBuilder, DEFAULT_MAX_TEMP_DIRECTORY_SIZE,+};use datafusion_execution::registry::SerializerRegistry;pub use datafusion_execution::TaskContext;pub use datafusion_expr::execution_props::ExecutionProps;@@ -711,7 +715,12 @@ impl SessionContext {}// TODO what about the other statements (like TransactionStart and TransactionEnd)LogicalPlan::Statement(Statement::SetVariable(stmt)) => {- self.set_variable(stmt).await+ 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,@@ -1069,7 +1078,7 @@ impl SessionContext {exec_err!("Schema '{schemaref}' doesn't exist.")}- async fn set_variable(&self, stmt: SetVariable) -> Result<DataFrame> {+ async fn set_variable(&self, stmt: SetVariable) -> Result<()> {let SetVariable {variable, value, ..} = stmt;@@ -1099,11 +1108,37 @@ impl SessionContext {for udf in udfs_to_update {state.register_udf(udf)?;}+ }- drop(state);+ Ok(())+ }++ async fn reset_variable(&self, stmt: ResetVariable) -> Result<()> {+ let variable = stmt.variable;+ if variable.starts_with("datafusion.runtime.") {+ return self.reset_runtime_variable(&variable);}- self.return_empty_dataframe()+ let mut state = self.state.write();+ state.config_mut().options_mut().reset(&variable)?;++ // Refresh UDFs to ensure configuration-dependent behavior updates+ let config_options = state.config().options();+ let udfs_to_update: Vec<_> = state+ .scalar_functions()+ .values()+ .filter_map(|udf| {+ udf.inner()+ .with_updated_config(config_options)+ .map(Arc::new)+ })+ .collect();++ for udf in udfs_to_update {+ state.register_udf(udf)?;+ }++ Ok(())}fn set_runtime_variable(&self, variable: &str, value: &str) -> Result<()> {@@ -1127,6 +1162,37 @@ impl SessionContext {builder.with_metadata_cache_limit(limit)}_ => return plan_err!("Unknown runtime configuration: {variable}"),+ // Remember to update `reset_runtime_variable()` when adding new options+ };++ *state = SessionStateBuilder::from(state.clone())+ .with_runtime_env(Arc::new(builder.build()?))+ .build();++ Ok(())+ }++ fn reset_runtime_variable(&self, variable: &str) -> Result<()> {+ let key = variable.strip_prefix("datafusion.runtime.").unwrap();++ let mut state = self.state.write();++ let mut builder = RuntimeEnvBuilder::from_runtime_env(state.runtime_env());+ match key {+ "memory_limit" => {+ builder.memory_pool = None;+ }+ "max_temp_directory_size" => {+ builder =+ builder.with_max_temp_directory_size(DEFAULT_MAX_TEMP_DIRECTORY_SIZE);+ }+ "temp_directory" => {+ builder.disk_manager_builder = Some(DiskManagerBuilder::default());+ }+ "metadata_cache_limit" => {+ builder = builder.with_metadata_cache_limit(DEFAULT_METADATA_CACHE_LIMIT);+ }+ _ => return plan_err!("Unknown runtime configuration: {variable}"),};*state = SessionStateBuilder::from(state.clone())diff --git a/datafusion/core/tests/macro_hygiene/mod.rs b/datafusion/core/tests/macro_hygiene/mod.rsindex c9f33f6fdf..48f0103113 100644--- a/datafusion/core/tests/macro_hygiene/mod.rs+++ b/datafusion/core/tests/macro_hygiene/mod.rs@@ -85,6 +85,7 @@ mod config_field {impl std::error::Error for E {}#[allow(dead_code)]+ #[derive(Default)]struct S;impl std::str::FromStr for S {diff --git a/datafusion/execution/src/cache/cache_manager.rs b/datafusion/execution/src/cache/cache_manager.rsindex 3e0f4065d1..98be9ce34b 100644--- a/datafusion/execution/src/cache/cache_manager.rs+++ b/datafusion/execution/src/cache/cache_manager.rs@@ -181,7 +181,7 @@ impl CacheManager {}}-const DEFAULT_METADATA_CACHE_LIMIT: usize = 50 * 1024 * 1024; // 50M+pub const DEFAULT_METADATA_CACHE_LIMIT: usize = 50 * 1024 * 1024; // 50M#[derive(Clone)]pub struct CacheManagerConfig {diff --git a/datafusion/execution/src/disk_manager.rs b/datafusion/execution/src/disk_manager.rsindex 5f741d3c78..b0fdb2d74f 100644--- a/datafusion/execution/src/disk_manager.rs+++ b/datafusion/execution/src/disk_manager.rs@@ -30,7 +30,7 @@ use tempfile::{Builder, NamedTempFile, TempDir};use crate::memory_pool::human_readable_size;-const DEFAULT_MAX_TEMP_DIRECTORY_SIZE: u64 = 100 * 1024 * 1024 * 1024; // 100GB+pub const DEFAULT_MAX_TEMP_DIRECTORY_SIZE: u64 = 100 * 1024 * 1024 * 1024; // 100GB/// Builder pattern for the [DiskManager] structure#[derive(Clone, Debug)]diff --git a/datafusion/expr/src/logical_plan/mod.rs b/datafusion/expr/src/logical_plan/mod.rsindex 7de2fd1174..f0212be294 100644--- a/datafusion/expr/src/logical_plan/mod.rs+++ b/datafusion/expr/src/logical_plan/mod.rs@@ -45,8 +45,9 @@ pub use plan::{SubqueryAlias, TableScan, ToStringifiedPlan, Union, Unnest, Values, Window,};pub use statement::{- Deallocate, Execute, Prepare, SetVariable, Statement, TransactionAccessMode,- TransactionConclusion, TransactionEnd, TransactionIsolationLevel, TransactionStart,+ Deallocate, Execute, Prepare, ResetVariable, SetVariable, Statement,+ TransactionAccessMode, TransactionConclusion, TransactionEnd,+ TransactionIsolationLevel, TransactionStart,};pub use datafusion_common::format::ExplainFormat;diff --git a/datafusion/expr/src/logical_plan/statement.rs b/datafusion/expr/src/logical_plan/statement.rsindex bfc6b53d11..49a938c9f6 100644--- a/datafusion/expr/src/logical_plan/statement.rs+++ b/datafusion/expr/src/logical_plan/statement.rs@@ -39,6 +39,8 @@ pub enum Statement {TransactionEnd(TransactionEnd),/// Set a VariableSetVariable(SetVariable),+ /// Reset a Variable+ ResetVariable(ResetVariable),/// Prepare a statement and find any bind parameters/// (e.g. `?`). This is used to implement SQL-prepared statements.Prepare(Prepare),@@ -66,6 +68,7 @@ impl Statement {Statement::TransactionStart(_) => "TransactionStart",Statement::TransactionEnd(_) => "TransactionEnd",Statement::SetVariable(_) => "SetVariable",+ Statement::ResetVariable(_) => "ResetVariable",Statement::Prepare(_) => "Prepare",Statement::Execute(_) => "Execute",Statement::Deallocate(_) => "Deallocate",@@ -109,6 +112,9 @@ impl Statement {}) => {write!(f, "SetVariable: set {variable:?} to {value:?}")}+ Statement::ResetVariable(ResetVariable { variable }) => {+ write!(f, "ResetVariable: reset {variable:?}")+ }Statement::Prepare(Prepare { name, fields, .. }) => {write!(f,@@ -194,6 +200,12 @@ pub struct SetVariable {pub value: String,}+/// Reset a configuration variable to its default+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]+pub struct ResetVariable {+ /// The variable name+ pub variable: String,+}/// Prepare a statement but do not execute it. Prepare statements can have 0 or more/// `Expr::Placeholder` expressions that are filled in during execution#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]diff --git a/datafusion/sql/src/parser.rs b/datafusion/sql/src/parser.rsindex 05dd878907..e3622bcaf2 100644--- a/datafusion/sql/src/parser.rs+++ b/datafusion/sql/src/parser.rs@@ -23,7 +23,7 @@use datafusion_common::config::SqlParserOptions;use datafusion_common::DataFusionError;use datafusion_common::{sql_err, Diagnostic, Span};-use sqlparser::ast::{ExprWithAlias, OrderByOptions};+use sqlparser::ast::{ExprWithAlias, Ident, OrderByOptions};use sqlparser::tokenizer::TokenWithSpan;use sqlparser::{ast::{@@ -259,6 +259,21 @@ impl fmt::Display for CreateExternalTable {}}+/// DataFusion extension for `RESET`+#[derive(Debug, Clone, PartialEq, Eq)]+pub enum ResetStatement {+ /// Reset a single configuration variable (stored as provided)+ Variable(ObjectName),+}++impl fmt::Display for ResetStatement {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ match self {+ ResetStatement::Variable(name) => write!(f, "RESET {name}"),+ }+ }+}+/// DataFusion SQL Statement.////// This can either be a [`Statement`] from [`sqlparser`] from a@@ -276,6 +291,8 @@ pub enum Statement {CopyTo(CopyToStatement),/// EXPLAIN for extensionsExplain(ExplainStatement),+ /// Extension: `RESET`+ Reset(ResetStatement),}impl fmt::Display for Statement {@@ -285,6 +302,7 @@ impl fmt::Display for Statement {Statement::CreateExternalTable(stmt) => write!(f, "{stmt}"),Statement::CopyTo(stmt) => write!(f, "{stmt}"),Statement::Explain(stmt) => write!(f, "{stmt}"),+ Statement::Reset(stmt) => write!(f, "{stmt}"),}}}@@ -521,6 +539,10 @@ impl<'a> DFParser<'a> {self.parser.next_token(); // EXPLAINself.parse_explain()}+ Keyword::RESET => {+ self.parser.next_token(); // RESET+ self.parse_reset()+ }_ => {// use sqlparser-rs parserself.parse_and_handle_statement()@@ -722,6 +744,47 @@ impl<'a> DFParser<'a> {}))}+ /// Parse a SQL `RESET`+ pub fn parse_reset(&mut self) -> Result<Statement, DataFusionError> {+ let mut parts: Vec<String> = Vec::new();+ let mut expecting_segment = true;++ loop {+ let next_token = self.parser.peek_token();+ match &next_token.token {+ Token::Word(word) => {+ self.parser.next_token();+ parts.push(word.value.clone());+ expecting_segment = false;+ }+ Token::SingleQuotedString(s)+ | Token::DoubleQuotedString(s)+ | Token::EscapedStringLiteral(s) => {+ self.parser.next_token();+ parts.push(s.clone());+ expecting_segment = false;+ }+ Token::Period => {+ self.parser.next_token();+ if expecting_segment || parts.is_empty() {+ return self.expected("configuration parameter", &next_token);+ }+ expecting_segment = true;+ }+ Token::EOF | Token::SemiColon => break,+ _ => return self.expected("configuration parameter", &next_token),+ }+ }++ if parts.is_empty() || expecting_segment {+ return self.expected("configuration parameter", &self.parser.peek_token());+ }++ let idents: Vec<Ident> = parts.into_iter().map(Ident::new).collect();+ let variable = ObjectName::from(idents);+ Ok(Statement::Reset(ResetStatement::Variable(variable)))+ }+pub fn parse_explain_format(&mut self) -> Result<Option<String>, DataFusionError> {if !self.parser.parse_keyword(Keyword::FORMAT) {return Ok(None);diff --git a/datafusion/sql/src/resolve.rs b/datafusion/sql/src/resolve.rsindex db5ddd5115..148e886161 100644--- a/datafusion/sql/src/resolve.rs+++ b/datafusion/sql/src/resolve.rs@@ -147,6 +147,7 @@ fn visit_statement(statement: &DFStatement, visitor: &mut RelationVisitor) {}},DFStatement::Explain(explain) => visit_statement(&explain.statement, visitor),+ DFStatement::Reset(_) => {}}}diff --git a/datafusion/sql/src/statement.rs b/datafusion/sql/src/statement.rsindex 52593a5840..91e11a4b65 100644--- a/datafusion/sql/src/statement.rs+++ b/datafusion/sql/src/statement.rs@@ -22,7 +22,7 @@ use std::sync::Arc;use crate::parser::{CopyToSource, CopyToStatement, CreateExternalTable, DFParser, ExplainStatement,- LexOrdering, Statement as DFStatement,+ LexOrdering, ResetStatement, Statement as DFStatement,};use crate::planner::{object_name_to_qualifier, ContextProvider, PlannerContext, SqlToRel,@@ -49,10 +49,10 @@ use datafusion_expr::{CreateIndex as PlanCreateIndex, CreateMemoryTable, CreateView, Deallocate,DescribeTable, DmlStatement, DropCatalogSchema, DropFunction, DropTable, DropView,EmptyRelation, Execute, Explain, ExplainFormat, Expr, ExprSchemable, Filter,- LogicalPlan, LogicalPlanBuilder, OperateFunctionArg, PlanType, Prepare, SetVariable,- SortExpr, Statement as PlanStatement, ToStringifiedPlan, TransactionAccessMode,- TransactionConclusion, TransactionEnd, TransactionIsolationLevel, TransactionStart,- Volatility, WriteOp,+ LogicalPlan, LogicalPlanBuilder, OperateFunctionArg, PlanType, Prepare,+ ResetVariable, SetVariable, SortExpr, Statement as PlanStatement, ToStringifiedPlan,+ TransactionAccessMode, TransactionConclusion, TransactionEnd,+ TransactionIsolationLevel, TransactionStart, Volatility, WriteOp,};use sqlparser::ast::{self, BeginTransactionKind, IndexColumn, IndexType, NullsDistinctOption, OrderByExpr,@@ -211,6 +211,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {format,statement,}) => self.explain_to_plan(verbose, analyze, format, *statement),+ DFStatement::Reset(statement) => self.reset_statement_to_plan(statement),}}@@ -1902,6 +1903,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {let variable = object_name_to_string(&variable);let mut variable_lower = variable.to_lowercase();+ // Map PostgreSQL "timezone" and MySQL "time.zone" aliases to DataFusion's canonical nameif variable_lower == "timezone" || variable_lower == "time.zone" {variable_lower = "datafusion.execution.time_zone".to_string();}@@ -1937,6 +1939,26 @@ impl<S: ContextProvider> SqlToRel<'_, S> {}}+ fn reset_statement_to_plan(&self, statement: ResetStatement) -> Result<LogicalPlan> {+ match statement {+ ResetStatement::Variable(variable) => {+ let variable = object_name_to_string(&variable);+ let mut variable_lower = variable.to_lowercase();++ // Map PostgreSQL "timezone" and MySQL "time.zone" aliases to DataFusion's canonical name+ if variable_lower == "timezone" || variable_lower == "time.zone" {+ variable_lower = "datafusion.execution.time_zone".to_string();+ }++ Ok(LogicalPlan::Statement(PlanStatement::ResetVariable(+ ResetVariable {+ variable: variable_lower,+ },+ )))+ }+ }+ }+fn delete_to_plan(&self,table_name: &ObjectName,diff --git a/datafusion/sqllogictest/test_files/set_variable.slt b/datafusion/sqllogictest/test_files/set_variable.sltindex bb4ac920d0..b11a631613 100644--- a/datafusion/sqllogictest/test_files/set_variable.slt+++ b/datafusion/sqllogictest/test_files/set_variable.slt@@ -244,3 +244,125 @@ SET TIME ZONE = 'Asia/Taipei2'statement error Arrow error: Parser error: Invalid timezone "Asia/Taipei2": failed to parse timezoneSELECT '2000-01-01T00:00:00'::TIMESTAMP::TIMESTAMPTZ++# reset variable restores default+statement ok+set datafusion.catalog.information_schema = true++statement ok+SET datafusion.execution.batch_size = 1024++query TT+SHOW datafusion.execution.batch_size+----+datafusion.execution.batch_size 1024++statement ok+RESET datafusion.execution.batch_size++query TT+SHOW datafusion.execution.batch_size+----+datafusion.execution.batch_size 8192++# reset variable with NULL default+statement ok+set datafusion.catalog.information_schema = true++statement ok+SET datafusion.execution.parquet.max_predicate_cache_size = '123'++query TT+SHOW datafusion.execution.parquet.max_predicate_cache_size+----+datafusion.execution.parquet.max_predicate_cache_size 123++statement ok+RESET datafusion.execution.parquet.max_predicate_cache_size++query TT+SHOW datafusion.execution.parquet.max_predicate_cache_size+----+datafusion.execution.parquet.max_predicate_cache_size NULL++# reset time zone via aliases+statement ok+set datafusion.catalog.information_schema = true++statement ok+SET TIMEZONE = '-03:00'++statement ok+RESET TIMEZONE++query TT+SHOW TIMEZONE+----+datafusion.execution.time_zone NULL++statement ok+SET TIME ZONE = '+09:00'++statement ok+RESET timezone++query TT+SHOW TIME ZONE+----+datafusion.execution.time_zone NULL++# reset runtime variables+statement ok+SET datafusion.runtime.memory_limit = '1M'++statement ok+RESET datafusion.runtime.memory_limit++statement ok+SET datafusion.runtime.max_temp_directory_size = '1M'++statement ok+RESET datafusion.runtime.max_temp_directory_size++statement ok+SET datafusion.runtime.metadata_cache_limit = '1M'++statement ok+RESET datafusion.runtime.metadata_cache_limit++statement ok+SET datafusion.runtime.temp_directory = './'++statement ok+RESET datafusion.runtime.temp_directory++# test memory limit effect+statement ok+SET datafusion.runtime.memory_limit = '1K'++# This query should fail with low memory+statement error Not enough memory to continue external sort+EXPLAIN ANALYZE SELECT * FROM generate_series(1, 1000) AS t1(v1) ORDER BY v1++statement ok+RESET datafusion.runtime.memory_limit++# This query should succeed after resetting memory limit+statement ok+EXPLAIN ANALYZE SELECT * FROM generate_series(1, 1000) AS t1(v1) ORDER BY v1++# reset invalid variable - typo in namespace+statement error DataFusion error: Invalid or Unsupported Configuration: Could not find config namespace "dataexplosion"+RESET dataexplosion.execution.batch_size++# reset invalid variable - wrong namespace prefix+statement error DataFusion error: Invalid or Unsupported Configuration: Config value "exec" not found on ConfigOptions+RESET datafusion.exec.batch_size++# reset invalid variable - typo in field name+statement error DataFusion error: Invalid or Unsupported Configuration: Config value "batches_size" not found on ExecutionOptions+RESET datafusion.execution.batches_size++# reset invalid variable - extra suffix on valid field+statement error DataFusion error: Invalid or Unsupported Configuration: Config field is a scalar usize and does not have nested field "bar"+RESET datafusion.execution.batch_size.bar