duckdb 0.6.2-dev447.0 → 0.6.2-dev480.0

package/src/duckdb.cpp

@@ -38,6 +38,7 @@ public:
 
 	DUCKDB_API void Set(const string &new_value, bool is_set_schema);
 	DUCKDB_API void Set(vector<string> &new_paths, bool is_set_schema = false);
+	DUCKDB_API void Reset();
 
 	DUCKDB_API const vector<string> &Get();
 	DUCKDB_API const vector<string> &GetSetPaths() {
@@ -4982,6 +4983,10 @@ string CatalogEntry::ToSQL() {
 namespace duckdb {
 
 CatalogSearchPath::CatalogSearchPath(ClientContext &context_p) : context(context_p) {
+	Reset();
+}
+
+void CatalogSearchPath::Reset() {
 	SetPaths(ParsePaths(""));
 }
 
@@ -8506,10 +8511,12 @@ private:
 //! The QueryProfilerHistory can be used to access the profiler of previous queries
 class QueryProfilerHistory {
 private:
+	static constexpr uint64_t DEFAULT_SIZE = 20;
+
 	//! Previous Query profilers
 	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> prev_profilers;
 	//! Previous Query profilers size
-	uint64_t prev_profilers_size = 20;
+	uint64_t prev_profilers_size = DEFAULT_SIZE;
 
 public:
 	deque<pair<transaction_t, shared_ptr<QueryProfiler>>> &GetPrevProfilers() {
@@ -8529,6 +8536,9 @@ public:
 	void SetProfilerHistorySize(uint64_t size) {
 		this->prev_profilers_size = size;
 	}
+	void ResetProfilerHistorySize() {
+		this->prev_profilers_size = DEFAULT_SIZE;
+	}
 };
 } // namespace duckdb
 
@@ -10000,6 +10010,17 @@ string CatalogTypeToString(CatalogType type) {
 namespace duckdb {
 
 // LCOV_EXCL_START
+
+vector<string> ListCompressionTypes(void) {
+	vector<string> compression_types;
+	uint8_t amount_of_compression_options = (uint8_t)CompressionType::COMPRESSION_COUNT;
+	compression_types.reserve(amount_of_compression_options);
+	for (uint8_t i = 0; i < amount_of_compression_options; i++) {
+		compression_types.push_back(CompressionTypeToString((CompressionType)i));
+	}
+	return compression_types;
+}
+
 CompressionType CompressionTypeFromString(const string &str) {
 	auto compression = StringUtil::Lower(str);
 	if (compression == "uncompressed") {
@@ -10544,6 +10565,8 @@ string LogicalOperatorToString(LogicalOperatorType type) {
 		return "EXPORT";
 	case LogicalOperatorType::LOGICAL_SET:
 		return "SET";
+	case LogicalOperatorType::LOGICAL_RESET:
+		return "RESET";
 	case LogicalOperatorType::LOGICAL_LOAD:
 		return "LOAD";
 	case LogicalOperatorType::LOGICAL_INVALID:
@@ -10732,6 +10755,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "EXPORT";
 	case PhysicalOperatorType::SET:
 		return "SET";
+	case PhysicalOperatorType::RESET:
+		return "RESET";
 	case PhysicalOperatorType::LOAD:
 		return "LOAD";
 	case PhysicalOperatorType::INOUT_FUNCTION:
@@ -71940,6 +71965,123 @@ string PhysicalReservoirSample::ParamsToString() const {
 }
 
 } // namespace duckdb
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/helper/physical_reset.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct DBConfig;
+struct ExtensionOption;
+
+//! PhysicalReset represents a RESET operation (e.g. RESET a = 42)
+class PhysicalReset : public PhysicalOperator {
+public:
+	PhysicalReset(const std::string &name_p, SetScope scope_p, idx_t estimated_cardinality)
+	    : PhysicalOperator(PhysicalOperatorType::RESET, {LogicalType::BOOLEAN}, estimated_cardinality), name(name_p),
+	      scope(scope_p) {
+	}
+
+public:
+	// Source interface
+	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	             LocalSourceState &lstate) const override;
+
+public:
+	const std::string name;
+	const SetScope scope;
+
+private:
+	void ResetExtensionVariable(ExecutionContext &context, DBConfig &config, ExtensionOption &extension_option) const;
+};
+
+} // namespace duckdb
+
+
+
+
+
+
+namespace duckdb {
+
+void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &config,
+                                           ExtensionOption &extension_option) const {
+	if (extension_option.set_function) {
+		extension_option.set_function(context.client, scope, extension_option.default_value);
+	}
+	if (scope == SetScope::GLOBAL) {
+		config.ResetOption(name);
+	} else {
+		auto &client_config = ClientConfig::GetConfig(context.client);
+		client_config.set_variables[name] = extension_option.default_value;
+	}
+}
+
+void PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+                            LocalSourceState &lstate) const {
+	auto option = DBConfig::GetOptionByName(name);
+	if (!option) {
+		// check if this is an extra extension variable
+		auto &config = DBConfig::GetConfig(context.client);
+		auto entry = config.extension_parameters.find(name);
+		if (entry == config.extension_parameters.end()) {
+			// it is not!
+			// get a list of all options
+			vector<string> potential_names = DBConfig::GetOptionNames();
+			for (auto &entry : config.extension_parameters) {
+				potential_names.push_back(entry.first);
+			}
+
+			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
+			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
+		}
+		ResetExtensionVariable(context, config, entry->second);
+		return;
+	}
+
+	// Transform scope
+	SetScope variable_scope = scope;
+	if (variable_scope == SetScope::AUTOMATIC) {
+		if (option->set_local) {
+			variable_scope = SetScope::SESSION;
+		} else {
+			D_ASSERT(option->set_global);
+			variable_scope = SetScope::GLOBAL;
+		}
+	}
+
+	switch (variable_scope) {
+	case SetScope::GLOBAL: {
+		if (!option->set_global) {
+			throw CatalogException("option \"%s\" cannot be reset globally", name);
+		}
+		auto &db = DatabaseInstance::GetDatabase(context.client);
+		auto &config = DBConfig::GetConfig(context.client);
+		config.ResetOption(&db, *option);
+		break;
+	}
+	case SetScope::SESSION:
+		if (!option->reset_local) {
+			throw CatalogException("option \"%s\" cannot be reset locally", name);
+		}
+		option->reset_local(context.client);
+		break;
+	default:
+		throw InternalException("Unsupported SetScope for variable");
+	}
+}
+
+} // namespace duckdb
 
 
 
@@ -72015,6 +72157,9 @@ void PhysicalResultCollector::BuildPipelines(Pipeline &current, MetaPipeline &me
 
 namespace duckdb {
 
+struct DBConfig;
+struct ExtensionOption;
+
 //! PhysicalSet represents a SET operation (e.g. SET a = 42)
 class PhysicalSet : public PhysicalOperator {
 public:
@@ -72032,6 +72177,9 @@ public:
 	const std::string name;
 	const Value value;
 	const SetScope scope;
+
+private:
+	void SetExtensionVariable(ExecutionContext &context, DBConfig &config, ExtensionOption &extension_option) const;
 };
 
 } // namespace duckdb
@@ -72043,6 +72191,21 @@ public:
 
 namespace duckdb {
 
+void PhysicalSet::SetExtensionVariable(ExecutionContext &context, DBConfig &config,
+                                       ExtensionOption &extension_option) const {
+	auto &target_type = extension_option.type;
+	Value target_value = value.CastAs(context.client, target_type);
+	if (extension_option.set_function) {
+		extension_option.set_function(context.client, scope, target_value);
+	}
+	if (scope == SetScope::GLOBAL) {
+		config.SetOption(name, move(target_value));
+	} else {
+		auto &client_config = ClientConfig::GetConfig(context.client);
+		client_config.set_variables[name] = move(target_value);
+	}
+}
+
 void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
                           LocalSourceState &lstate) const {
 	auto option = DBConfig::GetOptionByName(name);
@@ -72061,19 +72224,7 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
 			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
 		}
-		//! it is!
-		auto &extension_option = entry->second;
-		auto &target_type = extension_option.type;
-		Value target_value = value.CastAs(context.client, target_type);
-		if (extension_option.set_function) {
-			extension_option.set_function(context.client, scope, target_value);
-		}
-		if (scope == SetScope::GLOBAL) {
-			config.SetOption(name, move(target_value));
-		} else {
-			auto &client_config = ClientConfig::GetConfig(context.client);
-			client_config.set_variables[name] = move(target_value);
-		}
+		SetExtensionVariable(context, config, entry->second);
 		return;
 	}
 	SetScope variable_scope = scope;
@@ -89978,6 +90129,55 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCTERef &op
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_reset.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+class LogicalReset : public LogicalOperator {
+public:
+	LogicalReset(std::string name_p, SetScope scope_p)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RESET), name(name_p), scope(scope_p) {
+	}
+
+	std::string name;
+	SetScope scope;
+
+public:
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	idx_t EstimateCardinality(ClientContext &context) override;
+
+protected:
+	void ResolveTypes() override {
+		types.emplace_back(LogicalType::BOOLEAN);
+	}
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalReset &op) {
+	return make_unique<PhysicalReset>(op.name, op.scope, op.estimated_cardinality);
+}
+
+} // namespace duckdb
+
 
 
 //===----------------------------------------------------------------------===//
@@ -90925,6 +91125,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_SET:
 		plan = CreatePlan((LogicalSet &)op);
 		break;
+	case LogicalOperatorType::LOGICAL_RESET:
+		plan = CreatePlan((LogicalReset &)op);
+		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		plan = ((LogicalExtensionOperator &)op).CreatePlan(context, *this);
 
@@ -137868,6 +138071,7 @@ struct AccessModeSetting {
 	static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137877,6 +138081,7 @@ struct CheckpointThresholdSetting {
 	    "The WAL size threshold at which to automatically trigger a checkpoint (e.g. 1GB)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137886,6 +138091,7 @@ struct DebugCheckpointAbort {
 	    "DEBUG SETTING: trigger an abort while checkpointing for testing purposes";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137895,6 +138101,7 @@ struct DebugForceExternal {
 	    "DEBUG SETTING: force out-of-core computation for operators that support it, used for testing";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137904,6 +138111,7 @@ struct DebugForceNoCrossProduct {
 	    "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137912,6 +138120,7 @@ struct DebugWindowMode {
 	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137920,7 +138129,9 @@ struct DefaultCollationSetting {
 	static constexpr const char *Description = "The collation setting used when none is specified";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137929,6 +138140,7 @@ struct DefaultOrderSetting {
 	static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137937,6 +138149,7 @@ struct DefaultNullOrderSetting {
 	static constexpr const char *Description = "Null ordering used when none is specified (NULLS_FIRST or NULLS_LAST)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137945,6 +138158,7 @@ struct DisabledOptimizersSetting {
 	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137955,6 +138169,7 @@ struct EnableExternalAccessSetting {
 	    "readers, pandas replacement scans, etc)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137964,6 +138179,7 @@ struct EnableFSSTVectors {
 	    "Allow scans on FSST compressed segments to emit compressed vectors to utilize late decompression";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137972,6 +138188,7 @@ struct AllowUnsignedExtensionsSetting {
 	static constexpr const char *Description = "Allow to load extensions with invalid or missing signatures";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137980,6 +138197,7 @@ struct EnableObjectCacheSetting {
 	static constexpr const char *Description = "Whether or not object cache is used to cache e.g. Parquet metadata";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -137987,6 +138205,7 @@ struct EnableHTTPMetadataCacheSetting {
 	static constexpr const char *Name = "enable_http_metadata_cache";
 	static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
 	static Value GetSetting(ClientContext &context);
 };
@@ -137997,6 +138216,7 @@ struct EnableProfilingSetting {
 	    "Enables profiling, and sets the output format (JSON, QUERY_TREE, QUERY_TREE_OPTIMIZER)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138006,6 +138226,7 @@ struct EnableProgressBarSetting {
 	    "Enables the progress bar, printing progress to the terminal for long queries";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 struct EnableProgressBarPrintSetting {
@@ -138014,6 +138235,7 @@ struct EnableProgressBarPrintSetting {
 	    "Controls the printing of the progress bar, when 'enable_progress_bar' is true";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138022,6 +138244,7 @@ struct ExperimentalParallelCSVSetting {
 	static constexpr const char *Description = "Whether or not to use the experimental parallel CSV reader";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138030,6 +138253,7 @@ struct ExplainOutputSetting {
 	static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138038,6 +138262,7 @@ struct ExternalThreadsSetting {
 	static constexpr const char *Description = "The number of external threads that work on DuckDB tasks.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138046,6 +138271,7 @@ struct FileSearchPathSetting {
 	static constexpr const char *Description = "A comma separated list of directories to search for input files";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138054,6 +138280,7 @@ struct ForceCompressionSetting {
 	static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138062,6 +138289,7 @@ struct ForceBitpackingModeSetting {
 	static constexpr const char *Description = "DEBUG SETTING: forces a specific bitpacking mode";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138070,6 +138298,7 @@ struct HomeDirectorySetting {
 	static constexpr const char *Description = "Sets the home directory used by the system";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138079,6 +138308,7 @@ struct LogQueryPathSetting {
 	    "Specifies the path to which queries should be logged (default: empty string, queries are not logged)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138089,6 +138319,7 @@ struct MaximumExpressionDepthSetting {
 	    "expressions might lead to stack overflow errors.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138097,6 +138328,7 @@ struct MaximumMemorySetting {
 	static constexpr const char *Description = "The maximum memory of the system (e.g. 1GB)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138105,6 +138337,7 @@ struct PasswordSetting {
 	static constexpr const char *Description = "The password to use. Ignored for legacy compatibility.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138113,6 +138346,7 @@ struct PerfectHashThresholdSetting {
 	static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table (default: 12)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138122,6 +138356,7 @@ struct PreserveIdentifierCase {
 	    "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138132,6 +138367,7 @@ struct PreserveInsertionOrder {
 	    "that do not contain ORDER BY clauses.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138140,6 +138376,7 @@ struct ProfilerHistorySize {
 	static constexpr const char *Description = "Sets the profiler history size";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138149,6 +138386,7 @@ struct ProfileOutputSetting {
 	    "The file to which profile output should be saved, or empty to print to the terminal";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138157,6 +138395,7 @@ struct ProfilingModeSetting {
 	static constexpr const char *Description = "The profiling mode (STANDARD or DETAILED)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138166,6 +138405,7 @@ struct ProgressBarTimeSetting {
 	    "Sets the time (in milliseconds) how long a query needs to take before we start printing a progress bar";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138175,6 +138415,7 @@ struct SchemaSetting {
 	    "Sets the default search schema. Equivalent to setting search_path to a single value.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138184,6 +138425,7 @@ struct SearchPathSetting {
 	    "Sets the default search search path as a comma-separated list of values";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138192,6 +138434,7 @@ struct TempDirectorySetting {
 	static constexpr const char *Description = "Set the directory to which to write temp files";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138200,6 +138443,7 @@ struct ThreadsSetting {
 	static constexpr const char *Description = "The number of total threads used by the system.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
@@ -138208,30 +138452,53 @@ struct UsernameSetting {
 	static constexpr const char *Description = "The username to use. Ignored for legacy compatibility.";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
 	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
 	static Value GetSetting(ClientContext &context);
 };
 
 } // namespace duckdb
 
 
+#ifndef DUCKDB_NO_THREADS
+
+#endif
+
 namespace duckdb {
 
 #define DUCKDB_GLOBAL(_PARAM)                                                                                          \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::ResetGlobal,         \
+		    nullptr, _PARAM::GetSetting                                                                                \
+	}
 #define DUCKDB_GLOBAL_ALIAS(_ALIAS, _PARAM)                                                                            \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::ResetGlobal, nullptr,      \
+		    _PARAM::GetSetting                                                                                         \
+	}
 
 #define DUCKDB_LOCAL(_PARAM)                                                                                           \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, nullptr, _PARAM::ResetLocal,  \
+		    _PARAM::GetSetting                                                                                         \
+	}
 #define DUCKDB_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                             \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_ALIAS, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, nullptr, _PARAM::ResetLocal,        \
+		    _PARAM::GetSetting                                                                                         \
+	}
 
 #define DUCKDB_GLOBAL_LOCAL(_PARAM)                                                                                    \
-	{ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal,                     \
+		    _PARAM::ResetGlobal, _PARAM::ResetLocal, _PARAM::GetSetting                                                \
+	}
 #define DUCKDB_GLOBAL_LOCAL_ALIAS(_ALIAS, _PARAM)                                                                      \
-	{ _ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::GetSetting }
+	{                                                                                                                  \
+		_ALIAS, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, _PARAM::ResetGlobal,      \
+		    _PARAM::ResetLocal, _PARAM::GetSetting                                                                     \
+	}
 #define FINAL_SETTING                                                                                                  \
-	{ nullptr, nullptr, LogicalTypeId::INVALID, nullptr, nullptr, nullptr }
+	{ nullptr, nullptr, LogicalTypeId::INVALID, nullptr, nullptr, nullptr, nullptr, nullptr }
 
 static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting),
                                                  DUCKDB_GLOBAL(CheckpointThresholdSetting),
@@ -138335,24 +138602,68 @@ void DBConfig::SetOption(DatabaseInstance *db, const ConfigurationOption &option
 	if (!option.set_global) {
 		throw InternalException("Could not set option \"%s\" as a global option", option.name);
 	}
+	D_ASSERT(option.reset_global);
 	Value input = value.DefaultCastAs(option.parameter_type);
 	option.set_global(db, *this, input);
 }
 
+void DBConfig::ResetOption(DatabaseInstance *db, const ConfigurationOption &option) {
+	lock_guard<mutex> l(config_lock);
+	if (!option.reset_global) {
+		throw InternalException("Could not reset option \"%s\" as a global option", option.name);
+	}
+	D_ASSERT(option.set_global);
+	option.reset_global(db, *this);
+}
+
 void DBConfig::SetOption(const string &name, Value value) {
 	lock_guard<mutex> l(config_lock);
 	options.set_variables[name] = move(value);
 }
 
-void DBConfig::AddExtensionOption(string name, string description, LogicalType parameter,
-                                  set_option_callback_t function) {
-	extension_parameters.insert(make_pair(move(name), ExtensionOption(move(description), move(parameter), function)));
+void DBConfig::ResetOption(const string &name) {
+	lock_guard<mutex> l(config_lock);
+	auto extension_option = extension_parameters.find(name);
+	D_ASSERT(extension_option != extension_parameters.end());
+	auto &default_value = extension_option->second.default_value;
+	if (!default_value.IsNull()) {
+		// Default is not NULL, override the setting
+		options.set_variables[name] = default_value;
+	} else {
+		// Otherwise just remove it from the 'set_variables' map
+		options.set_variables.erase(name);
+	}
+}
+
+void DBConfig::AddExtensionOption(const string &name, string description, LogicalType parameter,
+                                  const Value &default_value, set_option_callback_t function) {
+	extension_parameters.insert(
+	    make_pair(name, ExtensionOption(move(description), move(parameter), function, default_value)));
+	if (!default_value.IsNull()) {
+		// Default value is set, insert it into the 'set_variables' list
+		options.set_variables[name] = default_value;
+	}
 }
 
 CastFunctionSet &DBConfig::GetCastFunctions() {
 	return *cast_functions;
 }
 
+void DBConfig::SetDefaultMaxMemory() {
+	auto memory = FileSystem::GetAvailableMemory();
+	if (memory != DConstants::INVALID_INDEX) {
+		options.maximum_memory = memory * 8 / 10;
+	}
+}
+
+void DBConfig::SetDefaultMaxThreads() {
+#ifndef DUCKDB_NO_THREADS
+	options.maximum_threads = std::thread::hardware_concurrency();
+#else
+	options.maximum_threads = 1;
+#endif
+}
+
 idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 	if (arg[0] == '-' || arg == "null" || arg == "none") {
 		return DConstants::INVALID_INDEX;
@@ -139263,17 +139574,10 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 		config.file_system = make_unique<VirtualFileSystem>();
 	}
 	if (config.options.maximum_memory == (idx_t)-1) {
-		auto memory = FileSystem::GetAvailableMemory();
-		if (memory != DConstants::INVALID_INDEX) {
-			config.options.maximum_memory = memory * 8 / 10;
-		}
+		config.SetDefaultMaxMemory();
 	}
 	if (new_config.options.maximum_threads == (idx_t)-1) {
-#ifndef DUCKDB_NO_THREADS
-		config.options.maximum_threads = std::thread::hardware_concurrency();
-#else
-		config.options.maximum_threads = 1;
-#endif
+		config.SetDefaultMaxThreads();
 	}
 	config.allocator = move(new_config.allocator);
 	if (!config.allocator) {
@@ -152358,6 +152662,10 @@ void AccessModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const
 	}
 }
 
+void AccessModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.access_mode = DBConfig().options.access_mode;
+}
+
 Value AccessModeSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	switch (config.options.access_mode) {
@@ -152380,6 +152688,10 @@ void CheckpointThresholdSetting::SetGlobal(DatabaseInstance *db, DBConfig &confi
 	config.options.checkpoint_wal_size = new_limit;
 }
 
+void CheckpointThresholdSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.checkpoint_wal_size = DBConfig().options.checkpoint_wal_size;
+}
+
 Value CheckpointThresholdSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value(StringUtil::BytesToHumanReadableString(config.options.checkpoint_wal_size));
@@ -152404,13 +152716,35 @@ void DebugCheckpointAbort::SetGlobal(DatabaseInstance *db, DBConfig &config, con
 	}
 }
 
+void DebugCheckpointAbort::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.checkpoint_abort = DBConfig().options.checkpoint_abort;
+}
+
 Value DebugCheckpointAbort::GetSetting(ClientContext &context) {
-	return Value();
+	auto &config = DBConfig::GetConfig(*context.db);
+	auto setting = config.options.checkpoint_abort;
+	switch (setting) {
+	case CheckpointAbort::NO_ABORT:
+		return "none";
+	case CheckpointAbort::DEBUG_ABORT_BEFORE_TRUNCATE:
+		return "before_truncate";
+	case CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER:
+		return "before_header";
+	case CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE:
+		return "after_free_list_write";
+	default:
+		throw InternalException("Type not implemented for CheckpointAbort");
+	}
 }
 
 //===--------------------------------------------------------------------===//
 // Debug Force External
 //===--------------------------------------------------------------------===//
+
+void DebugForceExternal::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).force_external = ClientConfig().force_external;
+}
+
 void DebugForceExternal::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).force_external = input.GetValue<bool>();
 }
@@ -152422,6 +152756,11 @@ Value DebugForceExternal::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Debug Force NoCrossProduct
 //===--------------------------------------------------------------------===//
+
+void DebugForceNoCrossProduct::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_no_cross_product;
+}
+
 void DebugForceNoCrossProduct::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).force_no_cross_product = input.GetValue<bool>();
 }
@@ -152446,6 +152785,10 @@ void DebugWindowMode::SetGlobal(DatabaseInstance *db, DBConfig &config, const Va
 	}
 }
 
+void DebugWindowMode::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.window_mode = DBConfig().options.window_mode;
+}
+
 Value DebugWindowMode::GetSetting(ClientContext &context) {
 	return Value();
 }
@@ -152458,6 +152801,15 @@ void DefaultCollationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
 	config.options.collation = parameter;
 }
 
+void DefaultCollationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.collation = DBConfig().options.collation;
+}
+
+void DefaultCollationSetting::ResetLocal(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	config.options.collation = DBConfig().options.collation;
+}
+
 void DefaultCollationSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	// bind the collation to verify that it exists
@@ -152486,6 +152838,10 @@ void DefaultOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, cons
 	}
 }
 
+void DefaultOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.default_order_type = DBConfig().options.default_order_type;
+}
+
 Value DefaultOrderSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	switch (config.options.default_order_type) {
@@ -152516,6 +152872,10 @@ void DefaultNullOrderSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
 	}
 }
 
+void DefaultNullOrderSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.default_null_order = DBConfig().options.default_null_order;
+}
+
 Value DefaultNullOrderSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	switch (config.options.default_null_order) {
@@ -152545,6 +152905,10 @@ void DisabledOptimizersSetting::SetGlobal(DatabaseInstance *db, DBConfig &config
 	config.options.disabled_optimizers = move(disabled_optimizers);
 }
 
+void DisabledOptimizersSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.disabled_optimizers = DBConfig().options.disabled_optimizers;
+}
+
 Value DisabledOptimizersSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	string result;
@@ -152568,6 +152932,13 @@ void EnableExternalAccessSetting::SetGlobal(DatabaseInstance *db, DBConfig &conf
 	config.options.enable_external_access = new_value;
 }
 
+void EnableExternalAccessSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	if (db) {
+		throw InvalidInputException("Cannot change enable_external_access setting while database is running");
+	}
+	config.options.enable_external_access = DBConfig().options.enable_external_access;
+}
+
 Value EnableExternalAccessSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.enable_external_access);
@@ -152580,6 +152951,10 @@ void EnableFSSTVectors::SetGlobal(DatabaseInstance *db, DBConfig &config, const
 	config.options.enable_fsst_vectors = input.GetValue<bool>();
 }
 
+void EnableFSSTVectors::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.enable_fsst_vectors = DBConfig().options.enable_fsst_vectors;
+}
+
 Value EnableFSSTVectors::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.enable_fsst_vectors);
@@ -152596,6 +152971,13 @@ void AllowUnsignedExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &c
 	config.options.allow_unsigned_extensions = new_value;
 }
 
+void AllowUnsignedExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	if (db) {
+		throw InvalidInputException("Cannot change allow_unsigned_extensions setting while database is running");
+	}
+	config.options.allow_unsigned_extensions = DBConfig().options.allow_unsigned_extensions;
+}
+
 Value AllowUnsignedExtensionsSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.allow_unsigned_extensions);
@@ -152608,6 +152990,10 @@ void EnableObjectCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
 	config.options.object_cache_enable = input.GetValue<bool>();
 }
 
+void EnableObjectCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.object_cache_enable = DBConfig().options.object_cache_enable;
+}
+
 Value EnableObjectCacheSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.object_cache_enable);
@@ -152620,6 +153006,10 @@ void EnableHTTPMetadataCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &c
 	config.options.http_metadata_cache_enable = input.GetValue<bool>();
 }
 
+void EnableHTTPMetadataCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.http_metadata_cache_enable = DBConfig().options.http_metadata_cache_enable;
+}
+
 Value EnableHTTPMetadataCacheSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.http_metadata_cache_enable);
@@ -152628,6 +153018,14 @@ Value EnableHTTPMetadataCacheSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Enable Profiling
 //===--------------------------------------------------------------------===//
+
+void EnableProfilingSetting::ResetLocal(ClientContext &context) {
+	auto &config = ClientConfig::GetConfig(context);
+	config.profiler_print_format = ClientConfig().profiler_print_format;
+	config.enable_profiler = ClientConfig().enable_profiler;
+	config.emit_profiler_output = ClientConfig().emit_profiler_output;
+}
+
 void EnableProfilingSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
 
@@ -152666,6 +153064,11 @@ Value EnableProfilingSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Enable Progress Bar
 //===--------------------------------------------------------------------===//
+
+void EnableProgressBarSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+}
+
 void EnableProgressBarSetting::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).enable_progress_bar = input.GetValue<bool>();
 }
@@ -152681,6 +153084,10 @@ void EnableProgressBarPrintSetting::SetLocal(ClientContext &context, const Value
 	ClientConfig::GetConfig(context).print_progress_bar = input.GetValue<bool>();
 }
 
+void EnableProgressBarPrintSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).print_progress_bar = ClientConfig().print_progress_bar;
+}
+
 Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(ClientConfig::GetConfig(context).print_progress_bar);
 }
@@ -152692,6 +153099,10 @@ void ExperimentalParallelCSVSetting::SetGlobal(DatabaseInstance *db, DBConfig &c
 	config.options.experimental_parallel_csv_reader = input.GetValue<bool>();
 }
 
+void ExperimentalParallelCSVSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.experimental_parallel_csv_reader = DBConfig().options.experimental_parallel_csv_reader;
+}
+
 Value ExperimentalParallelCSVSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BIGINT(config.options.experimental_parallel_csv_reader);
@@ -152700,6 +153111,11 @@ Value ExperimentalParallelCSVSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Explain Output
 //===--------------------------------------------------------------------===//
+
+void ExplainOutputSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).explain_output_type = ClientConfig().explain_output_type;
+}
+
 void ExplainOutputSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
 	if (parameter == "all") {
@@ -152734,6 +153150,10 @@ void ExternalThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, c
 	config.options.external_threads = input.GetValue<int64_t>();
 }
 
+void ExternalThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.external_threads = DBConfig().options.external_threads;
+}
+
 Value ExternalThreadsSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BIGINT(config.options.external_threads);
@@ -152742,6 +153162,12 @@ Value ExternalThreadsSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // File Search Path
 //===--------------------------------------------------------------------===//
+
+void FileSearchPathSetting::ResetLocal(ClientContext &context) {
+	auto &client_data = ClientData::Get(context);
+	client_data.file_search_path.clear();
+}
+
 void FileSearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
@@ -152758,20 +153184,25 @@ Value FileSearchPathSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
 	auto compression = StringUtil::Lower(input.ToString());
-	if (compression == "none") {
+	if (compression == "none" || compression == "auto") {
 		config.options.force_compression = CompressionType::COMPRESSION_AUTO;
 	} else {
 		auto compression_type = CompressionTypeFromString(compression);
 		if (compression_type == CompressionType::COMPRESSION_AUTO) {
-			throw ParserException("Unrecognized option for force_compression, expected none, uncompressed, rle, "
-			                      "dictionary, pfor, chimp, patas, bitpacking or fsst");
+			auto compression_types = StringUtil::Join(ListCompressionTypes(), ", ");
+			throw ParserException("Unrecognized option for PRAGMA force_compression, expected %s", compression_types);
 		}
 		config.options.force_compression = compression_type;
 	}
 }
 
+void ForceCompressionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.force_compression = DBConfig().options.force_compression;
+}
+
 Value ForceCompressionSetting::GetSetting(ClientContext &context) {
-	return Value(CompressionTypeToString(context.db->config.options.force_compression));
+	auto &config = DBConfig::GetConfig(*context.db);
+	return CompressionTypeToString(config.options.force_compression);
 }
 
 //===--------------------------------------------------------------------===//
@@ -152792,6 +153223,10 @@ void ForceBitpackingModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &confi
 	}
 }
 
+void ForceBitpackingModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.force_bitpacking_mode = DBConfig().options.force_bitpacking_mode;
+}
+
 Value ForceBitpackingModeSetting::GetSetting(ClientContext &context) {
 	return Value(BitpackingModeToString(context.db->config.options.force_bitpacking_mode));
 }
@@ -152799,6 +153234,11 @@ Value ForceBitpackingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Home Directory
 //===--------------------------------------------------------------------===//
+
+void HomeDirectorySetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).home_directory = ClientConfig().home_directory;
+}
+
 void HomeDirectorySetting::SetLocal(ClientContext &context, const Value &input) {
 	auto &config = ClientConfig::GetConfig(context);
 	config.home_directory = input.IsNull() ? string() : input.ToString();
@@ -152812,6 +153252,13 @@ Value HomeDirectorySetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Log Query Path
 //===--------------------------------------------------------------------===//
+
+void LogQueryPathSetting::ResetLocal(ClientContext &context) {
+	auto &client_data = ClientData::Get(context);
+	// TODO: verify that this does the right thing
+	client_data.log_query_writer = move(ClientData(context).log_query_writer);
+}
+
 void LogQueryPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto &client_data = ClientData::Get(context);
 	auto path = input.ToString();
@@ -152833,6 +153280,11 @@ Value LogQueryPathSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Maximum Expression Depth
 //===--------------------------------------------------------------------===//
+
+void MaximumExpressionDepthSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).max_expression_depth = ClientConfig().max_expression_depth;
+}
+
 void MaximumExpressionDepthSetting::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).max_expression_depth = input.GetValue<uint64_t>();
 }
@@ -152851,6 +153303,10 @@ void MaximumMemorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, con
 	}
 }
 
+void MaximumMemorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.SetDefaultMaxMemory();
+}
+
 Value MaximumMemorySetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value(StringUtil::BytesToHumanReadableString(config.options.maximum_memory));
@@ -152863,6 +153319,10 @@ void PasswordSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Va
 	// nop
 }
 
+void PasswordSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	// nop
+}
+
 Value PasswordSetting::GetSetting(ClientContext &context) {
 	return Value();
 }
@@ -152870,6 +153330,11 @@ Value PasswordSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Perfect Hash Threshold
 //===--------------------------------------------------------------------===//
+
+void PerfectHashThresholdSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).perfect_ht_threshold = ClientConfig().perfect_ht_threshold;
+}
+
 void PerfectHashThresholdSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto bits = input.GetValue<int32_t>();
 	if (bits < 0 || bits > 32) {
@@ -152885,6 +153350,11 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // PreserveIdentifierCase
 //===--------------------------------------------------------------------===//
+
+void PreserveIdentifierCase::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).preserve_identifier_case = ClientConfig().preserve_identifier_case;
+}
+
 void PreserveIdentifierCase::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).preserve_identifier_case = input.GetValue<bool>();
 }
@@ -152900,6 +153370,10 @@ void PreserveInsertionOrder::SetGlobal(DatabaseInstance *db, DBConfig &config, c
 	config.options.preserve_insertion_order = input.GetValue<bool>();
 }
 
+void PreserveInsertionOrder::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.preserve_insertion_order = DBConfig().options.preserve_insertion_order;
+}
+
 Value PreserveInsertionOrder::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BOOLEAN(config.options.preserve_insertion_order);
@@ -152908,6 +153382,12 @@ Value PreserveInsertionOrder::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profiler History Size
 //===--------------------------------------------------------------------===//
+
+void ProfilerHistorySize::ResetLocal(ClientContext &context) {
+	auto &client_data = ClientData::Get(context);
+	client_data.query_profiler_history->ResetProfilerHistorySize();
+}
+
 void ProfilerHistorySize::SetLocal(ClientContext &context, const Value &input) {
 	auto size = input.GetValue<int64_t>();
 	if (size <= 0) {
@@ -152924,6 +153404,11 @@ Value ProfilerHistorySize::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profile Output
 //===--------------------------------------------------------------------===//
+
+void ProfileOutputSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).profiler_save_location = ClientConfig().profiler_save_location;
+}
+
 void ProfileOutputSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto &config = ClientConfig::GetConfig(context);
 	auto parameter = input.ToString();
@@ -152938,6 +153423,13 @@ Value ProfileOutputSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profiling Mode
 //===--------------------------------------------------------------------===//
+
+void ProfilingModeSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).enable_profiler = ClientConfig().enable_profiler;
+	ClientConfig::GetConfig(context).enable_detailed_profiling = ClientConfig().enable_detailed_profiling;
+	ClientConfig::GetConfig(context).emit_profiler_output = ClientConfig().emit_profiler_output;
+}
+
 void ProfilingModeSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
 	auto &config = ClientConfig::GetConfig(context);
@@ -152965,6 +153457,12 @@ Value ProfilingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Progress Bar Time
 //===--------------------------------------------------------------------===//
+
+void ProgressBarTimeSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).wait_time = ClientConfig().wait_time;
+	ClientConfig::GetConfig(context).enable_progress_bar = ClientConfig().enable_progress_bar;
+}
+
 void ProgressBarTimeSetting::SetLocal(ClientContext &context, const Value &input) {
 	ClientConfig::GetConfig(context).wait_time = input.GetValue<int32_t>();
 	ClientConfig::GetConfig(context).enable_progress_bar = true;
@@ -152977,6 +153475,13 @@ Value ProgressBarTimeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Schema
 //===--------------------------------------------------------------------===//
+
+void SchemaSetting::ResetLocal(ClientContext &context) {
+	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
+	auto &client_data = ClientData::Get(context);
+	client_data.catalog_search_path->Reset();
+}
+
 void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
@@ -152990,6 +153495,13 @@ Value SchemaSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Search Path
 //===--------------------------------------------------------------------===//
+
+void SearchPathSetting::ResetLocal(ClientContext &context) {
+	// FIXME: catalog_search_path is controlled by both SchemaSetting and SearchPathSetting
+	auto &client_data = ClientData::Get(context);
+	client_data.catalog_search_path->Reset();
+}
+
 void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
@@ -153013,6 +153525,15 @@ void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, con
 	}
 }
 
+void TempDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.temporary_directory = DBConfig().options.temporary_directory;
+	config.options.use_temporary_directory = DBConfig().options.use_temporary_directory;
+	if (db) {
+		auto &buffer_manager = BufferManager::GetBufferManager(*db);
+		buffer_manager.SetTemporaryDirectory(config.options.temporary_directory);
+	}
+}
+
 Value TempDirectorySetting::GetSetting(ClientContext &context) {
 	auto &buffer_manager = BufferManager::GetBufferManager(context);
 	return Value(buffer_manager.GetTemporaryDirectory());
@@ -153028,6 +153549,10 @@ void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Val
 	}
 }
 
+void ThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.SetDefaultMaxThreads();
+}
+
 Value ThreadsSetting::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
 	return Value::BIGINT(config.options.maximum_threads);
@@ -153040,6 +153565,10 @@ void UsernameSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Va
 	// nop
 }
 
+void UsernameSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	// nop
+}
+
 Value UsernameSetting::GetSetting(ClientContext &context) {
 	return Value();
 }
@@ -157104,6 +157633,7 @@ void EstimatedProperties::SetCost(double new_cost) {
 
 
 
+
 
 
 namespace duckdb {
@@ -178800,7 +179330,14 @@ private:
 	unique_ptr<ExecuteStatement> TransformExecute(duckdb_libpgquery::PGNode *node);
 	unique_ptr<CallStatement> TransformCall(duckdb_libpgquery::PGNode *node);
 	unique_ptr<DropStatement> TransformDeallocate(duckdb_libpgquery::PGNode *node);
+
+	//===--------------------------------------------------------------------===//
+	// SetStatement Transform
+	//===--------------------------------------------------------------------===//
 	unique_ptr<SetStatement> TransformSet(duckdb_libpgquery::PGNode *node);
+	unique_ptr<SetStatement> TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt);
+	unique_ptr<SetStatement> TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt);
+
 	unique_ptr<SQLStatement> TransformCheckpoint(duckdb_libpgquery::PGNode *node);
 	unique_ptr<LoadStatement> TransformLoad(duckdb_libpgquery::PGNode *node);
 
@@ -180793,38 +181330,94 @@ string SelectStatement::ToString() const {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/enums/set_type.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+enum class SetType : uint8_t { SET = 0, RESET = 1 };
+
+} // namespace duckdb
+
 
 
 
 namespace duckdb {
 
 class SetStatement : public SQLStatement {
-public:
-	SetStatement(std::string name_p, Value value_p, SetScope scope_p);
-
 protected:
+	SetStatement(std::string name_p, SetScope scope_p, SetType type_p);
 	SetStatement(const SetStatement &other) = default;
 
 public:
 	unique_ptr<SQLStatement> Copy() const override;
 
+public:
 	std::string name;
-	Value value;
 	SetScope scope;
+	SetType set_type;
+};
+
+class SetVariableStatement : public SetStatement {
+public:
+	SetVariableStatement(std::string name_p, Value value_p, SetScope scope_p);
+
+protected:
+	SetVariableStatement(const SetVariableStatement &other) = default;
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+
+public:
+	Value value;
 };
+
+class ResetVariableStatement : public SetStatement {
+public:
+	ResetVariableStatement(std::string name_p, SetScope scope_p);
+
+protected:
+	ResetVariableStatement(const ResetVariableStatement &other) = default;
+};
+
 } // namespace duckdb
 
 
 namespace duckdb {
 
-SetStatement::SetStatement(std::string name_p, Value value_p, SetScope scope_p)
-    : SQLStatement(StatementType::SET_STATEMENT), name(move(name_p)), value(move(value_p)), scope(scope_p) {
+SetStatement::SetStatement(std::string name_p, SetScope scope_p, SetType type_p)
+    : SQLStatement(StatementType::SET_STATEMENT), name(move(name_p)), scope(scope_p), set_type(type_p) {
 }
 
 unique_ptr<SQLStatement> SetStatement::Copy() const {
 	return unique_ptr<SetStatement>(new SetStatement(*this));
 }
 
+// Set Variable
+
+SetVariableStatement::SetVariableStatement(std::string name_p, Value value_p, SetScope scope_p)
+    : SetStatement(move(name_p), scope_p, SetType::SET), value(move(value_p)) {
+}
+
+unique_ptr<SQLStatement> SetVariableStatement::Copy() const {
+	return unique_ptr<SetVariableStatement>(new SetVariableStatement(*this));
+}
+
+// Reset Variable
+
+ResetVariableStatement::ResetVariableStatement(std::string name_p, SetScope scope_p)
+    : SetStatement(move(name_p), scope_p, SetType::RESET) {
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -185658,7 +186251,7 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGNode
 		if (sqlite_compat_pragmas.find(info.name) != sqlite_compat_pragmas.end()) {
 			break;
 		}
-		auto set_statement = make_unique<SetStatement>(info.name, info.parameters[0], SetScope::AUTOMATIC);
+		auto set_statement = make_unique<SetVariableStatement>(info.name, info.parameters[0], SetScope::AUTOMATIC);
 		return move(set_statement);
 	}
 	case duckdb_libpgquery::PG_PRAGMA_TYPE_CALL:
@@ -186011,15 +186604,21 @@ SetScope ToSetScope(duckdb_libpgquery::VariableSetScope pg_scope) {
 	}
 }
 
-} // namespace
+SetType ToSetType(duckdb_libpgquery::VariableSetKind pg_kind) {
+	switch (pg_kind) {
+	case duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE:
+		return SetType::SET;
+	case duckdb_libpgquery::VariableSetKind::VAR_RESET:
+		return SetType::RESET;
+	default:
+		throw NotImplementedException("Can only SET or RESET a variable");
+	}
+}
 
-unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *node) {
-	D_ASSERT(node->type == duckdb_libpgquery::T_PGVariableSetStmt);
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableSetStmt *>(node);
+} // namespace
 
-	if (stmt->kind != duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE) {
-		throw ParserException("Can only SET a variable to a value");
-	}
+unique_ptr<SetStatement> Transformer::TransformSetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt) {
+	D_ASSERT(stmt->kind == duckdb_libpgquery::VariableSetKind::VAR_SET_VALUE);
 
 	if (stmt->scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
 		throw NotImplementedException("SET LOCAL is not implemented.");
@@ -186035,7 +186634,36 @@ unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *no
 
 	auto value = TransformValue(((duckdb_libpgquery::PGAConst *)stmt->args->head->data.ptr_value)->val)->value;
 
-	return make_unique<SetStatement>(name, value, ToSetScope(stmt->scope));
+	return make_unique<SetVariableStatement>(name, value, ToSetScope(stmt->scope));
+}
+
+unique_ptr<SetStatement> Transformer::TransformResetVariable(duckdb_libpgquery::PGVariableSetStmt *stmt) {
+	D_ASSERT(stmt->kind == duckdb_libpgquery::VariableSetKind::VAR_RESET);
+
+	if (stmt->scope == duckdb_libpgquery::VariableSetScope::VAR_SET_SCOPE_LOCAL) {
+		throw NotImplementedException("RESET LOCAL is not implemented.");
+	}
+
+	auto name = std::string(stmt->name);
+	D_ASSERT(!name.empty()); // parser protect us!
+
+	return make_unique<ResetVariableStatement>(name, ToSetScope(stmt->scope));
+}
+
+unique_ptr<SetStatement> Transformer::TransformSet(duckdb_libpgquery::PGNode *node) {
+	D_ASSERT(node->type == duckdb_libpgquery::T_PGVariableSetStmt);
+	auto stmt = reinterpret_cast<duckdb_libpgquery::PGVariableSetStmt *>(node);
+
+	SetType set_type = ToSetType(stmt->kind);
+
+	switch (set_type) {
+	case SetType::SET:
+		return TransformSetVariable(stmt);
+	case SetType::RESET:
+		return TransformResetVariable(stmt);
+	default:
+		throw NotImplementedException("Type not implemented for SetType");
+	}
 }
 
 } // namespace duckdb
@@ -193525,11 +194153,12 @@ BoundStatement Binder::Bind(SelectStatement &stmt) {
 
 
 
+
 #include <algorithm>
 
 namespace duckdb {
 
-BoundStatement Binder::Bind(SetStatement &stmt) {
+BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	BoundStatement result;
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
@@ -193539,6 +194168,31 @@ BoundStatement Binder::Bind(SetStatement &stmt) {
 	return result;
 }
 
+BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
+	BoundStatement result;
+	result.types = {LogicalType::BOOLEAN};
+	result.names = {"Success"};
+
+	result.plan = make_unique<LogicalReset>(stmt.name, stmt.scope);
+	properties.return_type = StatementReturnType::NOTHING;
+	return result;
+}
+
+BoundStatement Binder::Bind(SetStatement &stmt) {
+	switch (stmt.set_type) {
+	case SetType::SET: {
+		auto &set_stmt = (SetVariableStatement &)stmt;
+		return Bind(set_stmt);
+	}
+	case SetType::RESET: {
+		auto &set_stmt = (ResetVariableStatement &)stmt;
+		return Bind(set_stmt);
+	}
+	default:
+		throw NotImplementedException("Type not implemented for SetType");
+	}
+}
+
 } // namespace duckdb
 
 
@@ -200027,6 +200681,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_SET:
 		result = LogicalSet::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_RESET:
+		result = LogicalReset::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_LOAD:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
@@ -201617,6 +202274,27 @@ vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {
 
 
 
+namespace duckdb {
+
+void LogicalReset::Serialize(FieldWriter &writer) const {
+	writer.WriteString(name);
+	writer.WriteField(scope);
+}
+
+unique_ptr<LogicalOperator> LogicalReset::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
+	auto name = reader.ReadRequired<std::string>();
+	auto scope = reader.ReadRequired<SetScope>();
+	return make_unique<LogicalReset>(name, scope);
+}
+
+idx_t LogicalReset::EstimateCardinality(ClientContext &context) {
+	return 1;
+}
+
+} // namespace duckdb
+
+
+
 namespace duckdb {
 
 LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
@@ -287214,7 +287892,7 @@ static const yytype_uint16 yyrline[] =
      148,     7,    14,    20,    28,    29,     8,    22,    36,    48,
       56,    70,    71,    72,    73,    74,    87,    88,    93,    94,
       98,    99,     7,    18,    31,    35,    42,    53,    54,    60,
-      61,     9,    19,     2,     7,    14,    24,    25,    32,     3,
+      61,     9,    19,     2,     7,    15,    26,    27,    34,     3,
       10,    17,    24,    31,    38,    45,    52,    61,    61,    63,
       64,    68,    69,     6,     8,    21,    34,    52,    74,    75,
       76,    77,    11,    24,    37,    54,    55,    56,    61,    74,
@@ -310995,27 +311673,29 @@ yyreduce:
     {
 					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
 					n->kind = VAR_RESET;
+					n->scope = VAR_SET_SCOPE_GLOBAL;
 					n->name = (yyvsp[(1) - (1)].str);
 					(yyval.vsetstmt) = n;
 				;}
     break;
 
   case 1295:
-#line 15 "third_party/libpg_query/grammar/statements/variable_reset.y"
+#line 16 "third_party/libpg_query/grammar/statements/variable_reset.y"
     {
 					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
 					n->kind = VAR_RESET_ALL;
+					n->scope = VAR_SET_SCOPE_GLOBAL;
 					(yyval.vsetstmt) = n;
 				;}
     break;
 
   case 1296:
-#line 24 "third_party/libpg_query/grammar/statements/variable_reset.y"
+#line 26 "third_party/libpg_query/grammar/statements/variable_reset.y"
     { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;}
     break;
 
   case 1297:
-#line 26 "third_party/libpg_query/grammar/statements/variable_reset.y"
+#line 28 "third_party/libpg_query/grammar/statements/variable_reset.y"
     {
 					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
 					n->kind = VAR_RESET;
@@ -311025,7 +311705,7 @@ yyreduce:
     break;
 
   case 1298:
-#line 33 "third_party/libpg_query/grammar/statements/variable_reset.y"
+#line 35 "third_party/libpg_query/grammar/statements/variable_reset.y"
     {
 					PGVariableSetStmt *n = makeNode(PGVariableSetStmt);
 					n->kind = VAR_RESET;
@@ -311313,7 +311993,7 @@ yyreduce:
 
 
 /* Line 1267 of yacc.c.  */
-#line 26643 "third_party/libpg_query/grammar/grammar_out.cpp"
+#line 26645 "third_party/libpg_query/grammar/grammar_out.cpp"
       default: break;
     }
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);