duckdb 1.3.4 → 1.4.0

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/execution/operator/csv_scanner/csv_buffer.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
 
@@ -31,12 +32,12 @@ CSVBuffer::CSVBuffer(CSVFileHandle &file_handle, ClientContext &context, idx_t b
 	last_buffer = file_handle.FinishedReading();
 }
 
-shared_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t buffer_size, bool &has_seaked) const {
-	if (has_seaked) {
+shared_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t buffer_size, bool &has_seeked) const {
+	if (has_seeked) {
 		// This means that at some point a reload was done, and we are currently on the incorrect position in our file
 		// handle
 		file_handle.Seek(global_csv_start + actual_buffer_size);
-		has_seaked = false;
+		has_seeked = false;
 	}
 	auto next_csv_buffer = make_shared_ptr<CSVBuffer>(file_handle, context, buffer_size,
 	                                                  global_csv_start + actual_buffer_size, buffer_idx + 1);
@@ -68,7 +69,7 @@ void CSVBuffer::Reload(CSVFileHandle &file_handle) {
 
 shared_ptr<CSVBufferHandle> CSVBuffer::Pin(CSVFileHandle &file_handle, bool &has_seeked) {
 	auto &buffer_manager = BufferManager::GetBufferManager(context);
-	if (!is_pipe && block->IsUnloaded()) {
+	if (!block || (!is_pipe && block->IsUnloaded())) {
 		// We have to reload it from disk
 		block = nullptr;
 		Reload(file_handle);

package/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp

@@ -7,10 +7,10 @@
 
 namespace duckdb {
 
-CSVFileHandle::CSVFileHandle(ClientContext &context, unique_ptr<FileHandle> file_handle_p, const OpenFileInfo &file_p,
+CSVFileHandle::CSVFileHandle(ClientContext &context_p, unique_ptr<FileHandle> file_handle_p, const OpenFileInfo &file_p,
                              const CSVReaderOptions &options)
-    : compression_type(options.compression), file_handle(std::move(file_handle_p)),
-      encoder(context, options.encoding, options.buffer_size_option.GetValue()), file(file_p) {
+    : compression_type(options.compression), context(context_p), file_handle(std::move(file_handle_p)),
+      encoder(context_p, options.encoding, options.buffer_size_option.GetValue()), file(file_p) {
 	can_seek = file_handle->CanSeek();
 	on_disk_file = file_handle->OnDiskFile();
 	file_size = file_handle->GetFileSize();
@@ -76,11 +76,19 @@ bool CSVFileHandle::FinishedReading() const {
 }
 
 idx_t CSVFileHandle::Read(void *buffer, idx_t nr_bytes) {
+	// We avoid reading past the original size of the file for uncompressed files in utf-8 encoding. This avoids reading
+	// the data that is written after opening the file. This can be useful, for example when reading a duckdb log file
+	// in csv format while logging is enabled
+	if (file_handle->GetFileCompressionType() == FileCompressionType::UNCOMPRESSED && file_handle->CanSeek() &&
+	    encoder.encoding_name == "utf-8") {
+		nr_bytes = MinValue<idx_t>(nr_bytes, file_size - file_handle->SeekPosition());
+	}
+
 	requested_bytes += nr_bytes;
 	// if this is a plain file source OR we can seek we are not caching anything
 	idx_t bytes_read = 0;
 	if (encoder.encoding_name == "utf-8") {
-		bytes_read = static_cast<idx_t>(file_handle->Read(buffer, nr_bytes));
+		bytes_read = static_cast<idx_t>(file_handle->Read(context, buffer, nr_bytes));
 	} else {
 		bytes_read = encoder.Encode(*file_handle, static_cast<char *>(buffer), nr_bytes);
 	}

package/src/duckdb/src/execution/operator/csv_scanner/encode/csv_encoder.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/execution/operator/csv_scanner/encode/csv_encoder.hpp"
+
 #include "duckdb/common/exception.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/function/encoding_function.hpp"
@@ -37,14 +38,14 @@ void CSVEncoderBuffer::Reset() {
 	actual_encoded_buffer_size = 0;
 }
 
-CSVEncoder::CSVEncoder(ClientContext &context, const string &encoding_name_to_find, idx_t buffer_size)
-    : pass_on_byte(0) {
-	auto &config = DBConfig::GetConfig(context);
+CSVEncoder::CSVEncoder(ClientContext &context_p, const string &encoding_name_to_find, idx_t buffer_size)
+    : context(context_p), pass_on_byte(0) {
+	auto &config = DBConfig::GetConfig(context_p);
 	encoding_name = StringUtil::Lower(encoding_name_to_find);
 	auto function = config.GetEncodeFunction(encoding_name_to_find);
 	if (!function) {
 		// Maybe we can try to auto-load from our encodings extension, if this somehow fails, we just error.
-		if (Catalog::TryAutoLoad(context, "encodings")) {
+		if (Catalog::TryAutoLoad(context_p, "encodings")) {
 			// If it successfully loaded, we can try to get our function again
 			function = config.GetEncodeFunction(encoding_name_to_find);
 		}
@@ -54,7 +55,7 @@ CSVEncoder::CSVEncoder(ClientContext &context, const string &encoding_name_to_fi
 		auto loaded_encodings = config.GetLoadedEncodedFunctions();
 		std::ostringstream error;
 		error << "The CSV Reader does not support the encoding: \"" << encoding_name_to_find << "\"\n";
-		if (!context.db->ExtensionIsLoaded("encodings")) {
+		if (!context_p.db->ExtensionIsLoaded("encodings")) {
 			error << "It is possible that the encoding exists in the encodings extension. You can try \"INSTALL "
 			         "encodings; LOAD encodings\""
 			      << "\n";
@@ -117,14 +118,14 @@ idx_t CSVEncoder::Encode(FileHandle &file_handle_input, char *output_buffer, con
 			encoded_buffer.Ptr()[pass_on_buffer.size()] = pass_on_byte;
 		}
 		auto actual_encoded_bytes = static_cast<idx_t>(
-		    file_handle_input.Read(encoded_buffer.Ptr() + pass_on_buffer.size() + has_pass_on_byte,
+		    file_handle_input.Read(context, encoded_buffer.Ptr() + pass_on_buffer.size() + has_pass_on_byte,
 		                           encoded_buffer.GetCapacity() - pass_on_buffer.size() - has_pass_on_byte));
 		encoded_buffer.SetSize(actual_encoded_bytes + pass_on_buffer.size() + has_pass_on_byte);
 		if (actual_encoded_bytes < encoded_buffer.GetCapacity() - pass_on_buffer.size()) {
 			encoded_buffer.last_buffer = true;
 			has_pass_on_byte = false;
 		} else {
-			auto bytes_read = static_cast<idx_t>(file_handle_input.Read(&pass_on_byte, 1));
+			auto bytes_read = static_cast<idx_t>(file_handle_input.Read(context, &pass_on_byte, 1));
 			if (bytes_read == 0) {
 				encoded_buffer.last_buffer = true;
 				has_pass_on_byte = false;

package/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp

@@ -105,7 +105,7 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m
 	// Initialize Parse Chunk
 	parse_chunk.Initialize(buffer_allocator, logical_types, result_size);
 	for (auto &col : parse_chunk.data) {
-		vector_ptr.push_back(FlatVector::GetData<string_t>(col));
+		vector_ptr.push_back(FlatVector::GetData(col));
 		validity_mask.push_back(&FlatVector::Validity(col));
 	}
 
@@ -373,9 +373,10 @@ void StringValueResult::AddValueToVector(const char *value_ptr, idx_t size, bool
 			success = timestamp_format.TryParseTimestamp(
 			    value_ptr, size, static_cast<timestamp_t *>(vector_ptr[chunk_col_id])[number_of_rows]);
 		} else {
+			const bool use_offset = (parse_types[chunk_col_id].type_id == LogicalTypeId::TIMESTAMP_TZ);
 			success = Timestamp::TryConvertTimestamp(
-			              value_ptr, size, static_cast<timestamp_t *>(vector_ptr[chunk_col_id])[number_of_rows]) ==
-			          TimestampCastResult::SUCCESS;
+			              value_ptr, size, static_cast<timestamp_t *>(vector_ptr[chunk_col_id])[number_of_rows],
+			              use_offset) == TimestampCastResult::SUCCESS;
 		}
 		break;
 	}
@@ -504,8 +505,9 @@ void StringValueResult::Reset() {
 	}
 	// We keep a reference to the buffer from our current iteration if it already exists
 	shared_ptr<CSVBufferHandle> cur_buffer;
-	if (buffer_handles.find(iterator.GetBufferIdx()) != buffer_handles.end()) {
-		cur_buffer = buffer_handles[iterator.GetBufferIdx()];
+	auto handle_iter = buffer_handles.find(iterator.GetBufferIdx());
+	if (handle_iter != buffer_handles.end()) {
+		cur_buffer = handle_iter->second;
 	}
 	buffer_handles.clear();
 	idx_t actual_size = 0;

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp

@@ -394,6 +394,18 @@ void CSVSniffer::AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner> scanner,
 				if (stats.best_consistent_rows == consistent_rows && num_cols >= max_columns_found) {
 					// If both have not been escaped, this might get solved later on.
 					sniffing_state_machine.dialect_options.num_cols = num_cols;
+					if (options.dialect_options.skip_rows.IsSetByUser()) {
+						// If skip rows are set by the user, and we found dirty notes, we only accept it if either
+						// null_padding or ignore_errors is set
+						if (dirty_notes != 0 && !options.null_padding && !options.ignore_errors.GetValue()) {
+							return;
+						}
+						sniffing_state_machine.dialect_options.skip_rows = options.dialect_options.skip_rows.GetValue();
+					} else if (!options.null_padding) {
+						sniffing_state_machine.dialect_options.skip_rows = dirty_notes;
+					}
+					sniffing_state_machine.dialect_options.num_cols = num_cols;
+					lines_sniffed = sniffed_column_counts.result_position;
 					successful_candidates.emplace_back(std::move(scanner));
 					max_columns_found = num_cols;
 					return;
@@ -495,7 +507,7 @@ void CSVSniffer::RefineCandidates() {
 		return;
 	}
 	if (candidates.size() == 1 || candidates[0]->FinishedFile()) {
-		// Only one candidate nothing to refine or all candidates already checked
+		// Only one candidate nothing to refine, or all candidates already checked
 		return;
 	}
 
@@ -612,7 +624,8 @@ void CSVSniffer::DetectDialect() {
 		if (all_fail_max_line_size) {
 			error = line_error;
 		} else {
-			error = CSVError::SniffingError(options, dialect_candidates.Print(), max_columns_found_error, set_columns);
+			error = CSVError::SniffingError(options, dialect_candidates.Print(), max_columns_found_error, set_columns,
+			                                false);
 		}
 		error_handler->Error(error, true);
 	}

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp

@@ -351,7 +351,7 @@ void CSVSniffer::DetectHeader() {
 		// This file only contains a header, lets default to the lowest type of all.
 		detected_types.clear();
 		for (idx_t i = 0; i < names.size(); i++) {
-			detected_types.push_back(LogicalType::BOOLEAN);
+			detected_types.push_back(LogicalType::SQLNULL);
 		}
 	}
 	for (idx_t i = max_columns_found; i < names.size(); i++) {

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp

@@ -184,7 +184,7 @@ bool CSVSniffer::CanYouCastIt(ClientContext &context, const string_t value, cons
 			    ->second.GetValue()
 			    .TryParseTimestamp(value, dummy_value, error_message);
 		}
-		return Timestamp::TryConvertTimestamp(value_ptr, value_size, dummy_value, nullptr, true) ==
+		return Timestamp::TryConvertTimestamp(value_ptr, value_size, dummy_value, false, nullptr, true) ==
 		       TimestampCastResult::SUCCESS;
 	}
 	case LogicalTypeId::TIME: {
@@ -425,7 +425,7 @@ void CSVSniffer::DetectTypes() {
 	idx_t min_varchar_cols = max_columns_found + 1;
 	idx_t min_errors = NumericLimits<idx_t>::Maximum();
 	vector<LogicalType> return_types;
-	// check which info candidate leads to minimum amount of non-varchar columns...
+	// check which info candidate leads to the minimum number of non-varchar columns...
 	for (auto &candidate_cc : candidates) {
 		auto &sniffing_state_machine = candidate_cc->GetStateMachine();
 		unordered_map<idx_t, vector<LogicalType>> info_sql_types_candidates;
@@ -441,7 +441,7 @@ void CSVSniffer::DetectTypes() {
 		// Reset candidate for parsing
 		auto candidate = candidate_cc->UpgradeToStringValueScanner();
 		SetUserDefinedDateTimeFormat(*candidate->state_machine);
-		// Parse chunk and read csv with info candidate
+		// Parse chunk and read csv with info-candidate
 		auto &data_chunk = candidate->ParseChunk().ToChunk();
 		if (candidate->error_handler->AnyErrors() && !candidate->error_handler->HasError(MAXIMUM_LINE_SIZE) &&
 		    !candidate->state_machine->options.ignore_errors.GetValue()) {
@@ -502,7 +502,7 @@ void CSVSniffer::DetectTypes() {
 	}
 	if (!best_candidate) {
 		DialectCandidates dialect_candidates(options.dialect_options.state_machine_options);
-		auto error = CSVError::SniffingError(options, dialect_candidates.Print(), max_columns_found, set_columns);
+		auto error = CSVError::SniffingError(options, dialect_candidates.Print(), max_columns_found, set_columns, true);
 		error_handler->Error(error, true);
 	}
 	// Assert that it's all good at this point.

package/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_multi_file_info.cpp

@@ -8,8 +8,7 @@
 
 namespace duckdb {
 
-unique_ptr<MultiFileReaderInterface>
-CSVMultiFileInfo::InitializeInterface(ClientContext &context, MultiFileReader &reader, MultiFileList &file_list) {
+unique_ptr<MultiFileReaderInterface> CSVMultiFileInfo::CreateInterface(ClientContext &context) {
 	return make_uniq<CSVMultiFileInfo>();
 }
 
@@ -153,7 +152,6 @@ CSVSchema CSVSchemaDiscovery::SchemaDiscovery(ClientContext &context, shared_ptr
 			} else if (i < options.sql_type_list.size()) {
 				continue;
 			}
-			D_ASSERT(return_types[i].id() == LogicalTypeId::BOOLEAN);
 			// we default to varchar if all files are empty or only have a header after all the sniffing
 			return_types[i] = LogicalType::VARCHAR;
 		}
@@ -237,6 +235,13 @@ void CSVMultiFileInfo::FinalizeBindData(MultiFileBindData &multi_file_data) {
 			}
 		}
 	}
+	for (auto &type : multi_file_data.types) {
+		if (type.id() == LogicalTypeId::SQLNULL) {
+			// If after performing all the type detection of all files,
+			// we can't tell the type of column, we default to the highest type, a VARCHAR.
+			type = LogicalType::VARCHAR;
+		}
+	}
 	csv_data.Finalize();
 }
 
@@ -411,4 +416,8 @@ double CSVFileScan::GetProgressInFile(ClientContext &context) {
 	return file_progress * 100.0;
 }
 
+FileGlobInput CSVMultiFileInfo::GetGlobInput() {
+	return FileGlobInput(FileGlobOptions::FALLBACK_GLOB, "csv");
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp

@@ -438,12 +438,17 @@ CSVError CSVError::HeaderSniffingError(const CSVReaderOptions &options, const ve
 }
 
 CSVError CSVError::SniffingError(const CSVReaderOptions &options, const string &search_space, idx_t max_columns_found,
-                                 SetColumns &set_columns) {
+                                 SetColumns &set_columns, bool type_detection) {
 	std::ostringstream error;
 	// 1. Which file
 	error << "Error when sniffing file \"" << options.file_path << "\"." << '\n';
 	// 2. What's the error
-	error << "It was not possible to automatically detect the CSV Parsing dialect/types" << '\n';
+	error << "It was not possible to automatically detect the CSV parsing ";
+	if (type_detection) {
+		error << "types" << '\n';
+	} else {
+		error << "dialect" << '\n';
+	}
 
 	// 2. What was the search space?
 	error << "The search space used was:" << '\n';

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp

@@ -125,6 +125,10 @@ void CSVReaderOptions::SetDelimiter(const string &input) {
 	if (delim_str.size() > 4) {
 		throw InvalidInputException("The delimiter option cannot exceed a size of 4 bytes.");
 	}
+	if (this->dialect_options.state_machine_options.delimiter.IsSetByUser()) {
+		// we can't know in which order delim and sep were specified, so we throw an exception here
+		throw BinderException("CSV Reader function option delim and sep are aliases, only one can be supplied");
+	}
 	this->dialect_options.state_machine_options.delimiter.Set(delim_str);
 }
 

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -4,20 +4,22 @@
 #include "duckdb/parallel/thread_context.hpp"
 namespace duckdb {
 
-PhysicalFilter::PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
-                               idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::FILTER, std::move(types), estimated_cardinality) {
-	D_ASSERT(select_list.size() > 0);
-	if (select_list.size() > 1) {
-		// create a big AND out of the expressions
-		auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
-		for (auto &expr : select_list) {
-			conjunction->children.push_back(std::move(expr));
-		}
-		expression = std::move(conjunction);
-	} else {
+PhysicalFilter::PhysicalFilter(PhysicalPlan &physical_plan, vector<LogicalType> types,
+                               vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality)
+    : CachingPhysicalOperator(physical_plan, PhysicalOperatorType::FILTER, std::move(types), estimated_cardinality) {
+
+	D_ASSERT(!select_list.empty());
+	if (select_list.size() == 1) {
 		expression = std::move(select_list[0]);
+		return;
+	}
+
+	// Create a conjunction from the select list.
+	auto conjunction = make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
+	for (auto &expr : select_list) {
+		conjunction->children.push_back(std::move(expr));
 	}
+	expression = std::move(conjunction);
 }
 
 class FilterState : public CachingOperatorState {

package/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp

@@ -6,7 +6,8 @@
 
 namespace duckdb {
 
-PhysicalBatchCollector::PhysicalBatchCollector(PreparedStatementData &data) : PhysicalResultCollector(data) {
+PhysicalBatchCollector::PhysicalBatchCollector(PhysicalPlan &physical_plan, PreparedStatementData &data)
+    : PhysicalResultCollector(physical_plan, data) {
 }
 
 SinkResultType PhysicalBatchCollector::Sink(ExecutionContext &context, DataChunk &chunk,

package/src/duckdb/src/execution/operator/helper/physical_buffered_batch_collector.cpp

@@ -9,8 +9,8 @@
 
 namespace duckdb {
 
-PhysicalBufferedBatchCollector::PhysicalBufferedBatchCollector(PreparedStatementData &data)
-    : PhysicalResultCollector(data) {
+PhysicalBufferedBatchCollector::PhysicalBufferedBatchCollector(PhysicalPlan &physical_plan, PreparedStatementData &data)
+    : PhysicalResultCollector(physical_plan, data) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/helper/physical_buffered_collector.cpp

@@ -4,8 +4,9 @@
 
 namespace duckdb {
 
-PhysicalBufferedCollector::PhysicalBufferedCollector(PreparedStatementData &data, bool parallel)
-    : PhysicalResultCollector(data), parallel(parallel) {
+PhysicalBufferedCollector::PhysicalBufferedCollector(PhysicalPlan &physical_plan, PreparedStatementData &data,
+                                                     bool parallel)
+    : PhysicalResultCollector(physical_plan, data), parallel(parallel) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/helper/physical_execute.cpp

@@ -4,8 +4,8 @@
 
 namespace duckdb {
 
-PhysicalExecute::PhysicalExecute(PhysicalOperator &plan)
-    : PhysicalOperator(PhysicalOperatorType::EXECUTE, plan.types, idx_t(-1)), plan(plan) {
+PhysicalExecute::PhysicalExecute(PhysicalPlan &physical_plan, PhysicalOperator &plan)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXECUTE, plan.types, idx_t(-1)), plan(plan) {
 }
 
 vector<const_reference<PhysicalOperator>> PhysicalExecute::GetChildren() const {

package/src/duckdb/src/execution/operator/helper/physical_limit.cpp

@@ -8,9 +8,9 @@
 
 namespace duckdb {
 
-PhysicalLimit::PhysicalLimit(vector<LogicalType> types, BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
-                             idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality),
+PhysicalLimit::PhysicalLimit(PhysicalPlan &physical_plan, vector<LogicalType> types, BoundLimitNode limit_val_p,
+                             BoundLimitNode offset_val_p, idx_t estimated_cardinality)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality),
       limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
 }
 

package/src/duckdb/src/execution/operator/helper/physical_limit_percent.cpp

@@ -7,9 +7,10 @@
 
 namespace duckdb {
 
-PhysicalLimitPercent::PhysicalLimitPercent(vector<LogicalType> types, BoundLimitNode limit_val_p,
-                                           BoundLimitNode offset_val_p, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality),
+PhysicalLimitPercent::PhysicalLimitPercent(PhysicalPlan &physical_plan, vector<LogicalType> types,
+                                           BoundLimitNode limit_val_p, BoundLimitNode offset_val_p,
+                                           idx_t estimated_cardinality)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::LIMIT_PERCENT, std::move(types), estimated_cardinality),
       limit_val(std::move(limit_val_p)), offset_val(std::move(offset_val_p)) {
 	D_ASSERT(limit_val.Type() == LimitNodeType::CONSTANT_PERCENTAGE ||
 	         limit_val.Type() == LimitNodeType::EXPRESSION_PERCENTAGE);

package/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp

@@ -5,8 +5,9 @@
 
 namespace duckdb {
 
-PhysicalMaterializedCollector::PhysicalMaterializedCollector(PreparedStatementData &data, bool parallel)
-    : PhysicalResultCollector(data), parallel(parallel) {
+PhysicalMaterializedCollector::PhysicalMaterializedCollector(PhysicalPlan &physical_plan, PreparedStatementData &data,
+                                                             bool parallel)
+    : PhysicalResultCollector(physical_plan, data), parallel(parallel) {
 }
 
 SinkResultType PhysicalMaterializedCollector::Sink(ExecutionContext &context, DataChunk &chunk,

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -15,7 +15,7 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig &
 		config.ResetOption(name);
 	} else {
 		auto &client_config = ClientConfig::GetConfig(context.client);
-		client_config.set_variables[name] = extension_option.default_value;
+		client_config.set_variables[name.ToStdString()] = extension_option.default_value;
 	}
 }
 
@@ -28,13 +28,17 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 	auto &config = DBConfig::GetConfig(context.client);
 	config.CheckLock(name);
 	auto option = DBConfig::GetOptionByName(name);
+
 	if (!option) {
 		// check if this is an extra extension variable
-		auto entry = config.extension_parameters.find(name);
+		auto entry = config.extension_parameters.find(name.ToStdString());
 		if (entry == config.extension_parameters.end()) {
-			Catalog::AutoloadExtensionByConfigName(context.client, name);
-			entry = config.extension_parameters.find(name);
-			D_ASSERT(entry != config.extension_parameters.end());
+			auto extension_name = Catalog::AutoloadExtensionByConfigName(context.client, name);
+			entry = config.extension_parameters.find(name.ToStdString());
+			if (entry == config.extension_parameters.end()) {
+				throw InvalidInputException("Extension parameter %s was not found after autoloading",
+				                            name.ToStdString());
+			}
 		}
 		ResetExtensionVariable(context, config, entry->second);
 		return SourceResultType::FINISHED;
@@ -45,16 +49,32 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 	if (variable_scope == SetScope::AUTOMATIC) {
 		if (option->set_local) {
 			variable_scope = SetScope::SESSION;
-		} else {
-			D_ASSERT(option->set_global);
+		} else if (option->set_global) {
 			variable_scope = SetScope::GLOBAL;
+		} else {
+			variable_scope = option->default_scope;
 		}
 	}
 
+	if (option->default_value) {
+		if (option->set_callback) {
+			SettingCallbackInfo info(context.client, variable_scope);
+			auto parameter_type = DBConfig::ParseLogicalType(option->parameter_type);
+			Value reset_val = Value(option->default_value).CastAs(context.client, parameter_type);
+			option->set_callback(info, reset_val);
+		}
+		if (variable_scope == SetScope::SESSION) {
+			auto &client_config = ClientConfig::GetConfig(context.client);
+			client_config.set_variables.erase(name.ToStdString());
+		} else {
+			config.ResetGenericOption(name);
+		}
+		return SourceResultType::FINISHED;
+	}
 	switch (variable_scope) {
 	case SetScope::GLOBAL: {
 		if (!option->set_global) {
-			throw CatalogException("option \"%s\" cannot be reset globally", name);
+			throw CatalogException("option \"%s\" cannot be reset globally", name.ToStdString());
 		}
 		auto &db = DatabaseInstance::GetDatabase(context.client);
 		config.ResetOption(&db, *option);
@@ -62,7 +82,7 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 	}
 	case SetScope::SESSION:
 		if (!option->reset_local) {
-			throw CatalogException("option \"%s\" cannot be reset locally", name);
+			throw CatalogException("option \"%s\" cannot be reset locally", name.ToStdString());
 		}
 		option->reset_local(context.client);
 		break;

package/src/duckdb/src/execution/operator/helper/physical_result_collector.cpp

@@ -13,35 +13,38 @@
 
 namespace duckdb {
 
-PhysicalResultCollector::PhysicalResultCollector(PreparedStatementData &data)
-    : PhysicalOperator(PhysicalOperatorType::RESULT_COLLECTOR, {LogicalType::BOOLEAN}, 0),
+PhysicalResultCollector::PhysicalResultCollector(PhysicalPlan &physical_plan, PreparedStatementData &data)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::RESULT_COLLECTOR, {LogicalType::BOOLEAN}, 0),
       statement_type(data.statement_type), properties(data.properties), plan(data.physical_plan->Root()),
       names(data.names) {
-	this->types = data.types;
+	types = data.types;
 }
 
-unique_ptr<PhysicalResultCollector> PhysicalResultCollector::GetResultCollector(ClientContext &context,
-                                                                                PreparedStatementData &data) {
-	if (!PhysicalPlanGenerator::PreserveInsertionOrder(context, data.physical_plan->Root())) {
-		// the plan is not order preserving, so we just use the parallel materialized collector
-		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedCollector>(data, true);
-		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, true);
-	} else if (!PhysicalPlanGenerator::UseBatchIndex(context, data.physical_plan->Root())) {
-		// the plan is order preserving, but we cannot use the batch index: use a single-threaded result collector
+PhysicalOperator &PhysicalResultCollector::GetResultCollector(ClientContext &context, PreparedStatementData &data) {
+	auto &physical_plan = *data.physical_plan;
+	auto &root = physical_plan.Root();
+
+	if (!PhysicalPlanGenerator::PreserveInsertionOrder(context, root)) {
+		// Not an order-preserving plan: use the parallel materialized collector.
 		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedCollector>(data, false);
+			return physical_plan.Make<PhysicalBufferedCollector>(data, true);
 		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalMaterializedCollector>(data, false);
-	} else {
-		// we care about maintaining insertion order and the sources all support batch indexes
-		// use a batch collector
+		return physical_plan.Make<PhysicalMaterializedCollector>(data, true);
+	}
+
+	if (!PhysicalPlanGenerator::UseBatchIndex(context, root)) {
+		// Order-preserving plan, and we cannot use the batch index: use single-threaded result collector.
 		if (data.is_streaming) {
-			return make_uniq_base<PhysicalResultCollector, PhysicalBufferedBatchCollector>(data);
+			return physical_plan.Make<PhysicalBufferedCollector>(data, false);
 		}
-		return make_uniq_base<PhysicalResultCollector, PhysicalBatchCollector>(data);
+		return physical_plan.Make<PhysicalMaterializedCollector>(data, false);
+	}
+
+	// Order-preserving plan, and we can use the batch index: use a batch collector.
+	if (data.is_streaming) {
+		return physical_plan.Make<PhysicalBufferedBatchCollector>(data);
 	}
+	return physical_plan.Make<PhysicalBatchCollector>(data);
 }
 
 vector<const_reference<PhysicalOperator>> PhysicalResultCollector::GetChildren() const {