This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datafusion.git
The following commit(s) were added to refs/heads/main by this push:
new 71fcd03d61 feat: add RESET statement for configuration variabless
(#18408)
71fcd03d61 is described below
commit 71fcd03d614c466fdc8820084dc2896f69775f2b
Author: Alex Huang <[email protected]>
AuthorDate: Mon Nov 17 21:24:51 2025 +0200
feat: add RESET statement for configuration variabless (#18408)
## Which issue does this PR close?
<!--
We generally require a GitHub issue to be filed for all bug fixes and
enhancements and this helps us generate change logs for our releases.
You can link an issue to this PR using the GitHub syntax. For example
`Closes #123` indicates that this PR will close issue #123.
-->
- Closes #18384
## Rationale for this change
Without a SQL-level reset, clients that SET DataFusion options have to
rebuild the session to recover defaults
<!--
Why are you proposing this change? If this is already explained clearly
in the issue then this section is not needed.
Explaining clearly why changes are proposed helps reviewers understand
your changes and offer better suggestions for fixes.
-->
## What changes are included in this PR?
- Extended the config macros/traits so every namespace knows how to
restore default values
- Added the `ResetVariable`
<!--
There is no need to duplicate the description in the issue here but it
is sometimes worth providing a summary of the individual changes in this
PR.
-->
## Are these changes tested?
Yes
<!--
We typically require tests for all PRs in order to:
1. Prevent the code from being accidentally broken by subsequent changes
2. Serve as another way to document the expected behavior of the code
If tests are not included in your PR, please explain why (for example,
are they covered by existing tests)?
-->
## Are there any user-facing changes?
<!--
If there are user-facing changes then we may require documentation to be
updated before approving the PR.
-->
<!--
If there are any breaking changes to public APIs, please add the `api
change` label.
-->
Yes, SQL clients (including the CLI) can issue RESET
---------
Co-authored-by: Bruce Ritchie <[email protected]>
---
datafusion/common/src/config.rs | 107 +++++++++++++++++-
datafusion/core/src/execution/context/mod.rs | 80 ++++++++++++--
datafusion/core/tests/macro_hygiene/mod.rs | 1 +
datafusion/execution/src/cache/cache_manager.rs | 2 +-
datafusion/execution/src/disk_manager.rs | 2 +-
datafusion/expr/src/logical_plan/mod.rs | 5 +-
datafusion/expr/src/logical_plan/statement.rs | 12 ++
datafusion/sql/src/parser.rs | 65 ++++++++++-
datafusion/sql/src/resolve.rs | 1 +
datafusion/sql/src/statement.rs | 32 +++++-
.../sqllogictest/test_files/set_variable.slt | 122 +++++++++++++++++++++
11 files changed, 410 insertions(+), 19 deletions(-)
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
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
