Skip to content

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.rs
index 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/16
let column_names = vec!["double_field", "float_field"];
diff --git a/datafusion/core/src/execution/context/mod.rs b/datafusion/core/src/execution/context/mod.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 Variable
SetVariable(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.rs
index 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 extensions
Explain(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(); // EXPLAIN
self.parse_explain()
}
+ Keyword::RESET => {
+ self.parser.next_token(); // RESET
+ self.parse_reset()
+ }
_ => {
// use sqlparser-rs parser
self.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.rs
index 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.rs
index 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 name
if 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.slt
index 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 timezone
SELECT '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