duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -10,31 +10,33 @@ CSVFileScan::CSVFileScan(ClientContext &context, shared_ptr<CSVBufferManager> bu
                          vector<LogicalType> &file_schema)
     : file_path(options_p.file_path), file_idx(0), buffer_manager(std::move(buffer_manager_p)),
       state_machine(std::move(state_machine_p)), file_size(buffer_manager->file_handle->FileSize()),
-      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())),
+      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())),
       on_disk_file(buffer_manager->file_handle->OnDiskFile()), options(options_p) {
+
+	auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan");
 	if (bind_data.initial_reader.get()) {
 		auto &union_reader = *bind_data.initial_reader;
 		names = union_reader.GetNames();
 		options = union_reader.options;
 		types = union_reader.GetTypes();
-		MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                  bind_data.return_names, column_ids, nullptr, file_path, context);
+		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
+		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
 		InitializeFileNamesTypes();
 		return;
 	} else if (!bind_data.column_info.empty()) {
 		// Serialized Union By name
 		names = bind_data.column_info[0].names;
 		types = bind_data.column_info[0].types;
-		MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                  bind_data.return_names, column_ids, nullptr, file_path, context);
+		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
+		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
 		InitializeFileNamesTypes();
 		return;
 	}
 	names = bind_data.return_names;
 	types = bind_data.return_types;
 	file_schema = bind_data.return_types;
-	MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-	                                  bind_data.return_names, column_ids, nullptr, file_path, context);
+	multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
+	                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
 
 	InitializeFileNamesTypes();
 }
@@ -43,7 +45,8 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
                          const idx_t file_idx_p, const ReadCSVData &bind_data, const vector<column_t> &column_ids,
                          const vector<LogicalType> &file_schema)
     : file_path(file_path_p), file_idx(file_idx_p),
-      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
+      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
+	auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan");
 	if (file_idx < bind_data.union_readers.size()) {
 		// we are doing UNION BY NAME - fetch the options from the union reader for this file
 		optional_ptr<CSVFileScan> union_reader_ptr;
@@ -63,9 +66,9 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
 			options = union_reader.options;
 			types = union_reader.GetTypes();
 			state_machine = union_reader.state_machine;
-			MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind,
-			                                  bind_data.return_types, bind_data.return_names, column_ids, nullptr,
-			                                  file_path, context);
+			multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind,
+			                                    bind_data.return_types, bind_data.return_names, column_ids, nullptr,
+			                                    file_path, context, nullptr);
 
 			InitializeFileNamesTypes();
 			return;
@@ -73,7 +76,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
 	}
 
 	// Initialize Buffer Manager
-	buffer_manager = make_shared<CSVBufferManager>(context, options, file_path, file_idx);
+	buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, file_path, file_idx);
 	// Initialize On Disk and Size of file
 	on_disk_file = buffer_manager->file_handle->OnDiskFile();
 	file_size = buffer_manager->file_handle->FileSize();
@@ -89,11 +92,11 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
 			CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
 			sniffer.SniffCSV();
 		}
-		state_machine = make_shared<CSVStateMachine>(
+		state_machine = make_shared_ptr<CSVStateMachine>(
 		    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
 
-		MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-		                                  bind_data.return_names, column_ids, nullptr, file_path, context);
+		multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
+		                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
 		InitializeFileNamesTypes();
 		return;
 	}
@@ -120,18 +123,18 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
 
 	names = bind_data.csv_names;
 	types = bind_data.csv_types;
-	state_machine =
-	    make_shared<CSVStateMachine>(state_machine_cache.Get(options.dialect_options.state_machine_options), options);
+	state_machine = make_shared_ptr<CSVStateMachine>(
+	    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
 
-	MultiFileReader::InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
-	                                  bind_data.return_names, column_ids, nullptr, file_path, context);
+	multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types,
+	                                    bind_data.return_names, column_ids, nullptr, file_path, context, nullptr);
 	InitializeFileNamesTypes();
 }
 
 CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, CSVReaderOptions &options_p)
     : file_path(file_name), file_idx(0),
-      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
-	buffer_manager = make_shared<CSVBufferManager>(context, options, file_path, file_idx);
+      error_handler(make_shared_ptr<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
+	buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, file_path, file_idx);
 	// Initialize On Disk and Size of file
 	on_disk_file = buffer_manager->file_handle->OnDiskFile();
 	file_size = buffer_manager->file_handle->FileSize();
@@ -151,8 +154,8 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, CSVRea
 		options.dialect_options.num_cols = options.sql_type_list.size();
 	}
 	// Initialize State Machine
-	state_machine =
-	    make_shared<CSVStateMachine>(state_machine_cache.Get(options.dialect_options.state_machine_options), options);
+	state_machine = make_shared_ptr<CSVStateMachine>(
+	    state_machine_cache.Get(options.dialect_options.state_machine_options), options);
 }
 
 void CSVFileScan::InitializeFileNamesTypes() {

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

@@ -14,7 +14,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr<CSVBuf
       sniffer_mismatch_error(options.sniffer_user_mismatch_error), bind_data(bind_data_p) {
 
 	if (buffer_manager && buffer_manager->GetFilePath() == files[0]) {
-		auto state_machine = make_shared<CSVStateMachine>(
+		auto state_machine = make_shared_ptr<CSVStateMachine>(
 		    CSVStateMachineCache::Get(context).Get(options.dialect_options.state_machine_options), options);
 		// If we already have a buffer manager, we don't need to reconstruct it to the first file
 		file_scans.emplace_back(make_uniq<CSVFileScan>(context, buffer_manager, state_machine, options, bind_data,
@@ -22,7 +22,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr<CSVBuf
 	} else {
 		// If not we need to construct it for the first file
 		file_scans.emplace_back(
-		    make_uniq<CSVFileScan>(context, files[0], options, 0, bind_data, column_ids, file_schema));
+		    make_uniq<CSVFileScan>(context, files[0], options, 0U, bind_data, column_ids, file_schema));
 	};
 	// There are situations where we only support single threaded scanning
 	bool many_csv_files = files.size() > 1 && files.size() > system_threads * 2;
@@ -36,7 +36,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr<CSVBuf
 		auto buffer_size = file_scans.back()->buffer_manager->GetBuffer(0)->actual_size;
 		current_boundary = CSVIterator(0, 0, 0, 0, buffer_size);
 	}
-	current_buffer_in_use = make_shared<CSVBufferUsage>(*file_scans.back()->buffer_manager, 0);
+	current_buffer_in_use = make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager, 0);
 }
 
 double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const {
@@ -67,8 +67,8 @@ unique_ptr<StringValueScanner> CSVGlobalState::Next(optional_ptr<StringValueScan
 			current_file = file_scans.back();
 		} else {
 			lock_guard<mutex> parallel_lock(main_mutex);
-			file_scans.emplace_back(make_shared<CSVFileScan>(context, bind_data.files[cur_idx], bind_data.options,
-			                                                 cur_idx, bind_data, column_ids, file_schema));
+			file_scans.emplace_back(make_shared_ptr<CSVFileScan>(context, bind_data.files[cur_idx], bind_data.options,
+			                                                     cur_idx, bind_data, column_ids, file_schema));
 			current_file = file_scans.back();
 		}
 		if (previous_scanner) {
@@ -88,7 +88,7 @@ unique_ptr<StringValueScanner> CSVGlobalState::Next(optional_ptr<StringValueScan
 	}
 	if (current_buffer_in_use->buffer_idx != current_boundary.GetBufferIdx()) {
 		current_buffer_in_use =
-		    make_shared<CSVBufferUsage>(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx());
+		    make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx());
 	}
 	// We first create the scanner for the current boundary
 	auto &current_file = *file_scans.back();
@@ -111,13 +111,13 @@ unique_ptr<StringValueScanner> CSVGlobalState::Next(optional_ptr<StringValueScan
 		auto current_file_idx = current_file.file_idx + 1;
 		if (current_file_idx < bind_data.files.size()) {
 			// If we have a next file we have to construct the file scan for that
-			file_scans.emplace_back(make_shared<CSVFileScan>(context, bind_data.files[current_file_idx],
-			                                                 bind_data.options, current_file_idx, bind_data, column_ids,
-			                                                 file_schema));
+			file_scans.emplace_back(make_shared_ptr<CSVFileScan>(context, bind_data.files[current_file_idx],
+			                                                     bind_data.options, current_file_idx, bind_data,
+			                                                     column_ids, file_schema));
 			// And re-start the boundary-iterator
 			auto buffer_size = file_scans.back()->buffer_manager->GetBuffer(0)->actual_size;
 			current_boundary = CSVIterator(current_file_idx, 0, 0, 0, buffer_size);
-			current_buffer_in_use = make_shared<CSVBufferUsage>(*file_scans.back()->buffer_manager, 0);
+			current_buffer_in_use = make_shared_ptr<CSVBufferUsage>(*file_scans.back()->buffer_manager, 0);
 		} else {
 			// If not we are done with this CSV Scanning
 			finished = true;
@@ -289,12 +289,12 @@ void CSVGlobalState::FillRejectsTable() {
 						// 4. Byte Position of the row error
 						errors_appender.Append(error.row_byte_position + 1);
 						// 5. Byte Position where error occurred
-						if (error.byte_position == -1) {
+						if (!error.byte_position.IsValid()) {
 							// This means this error comes from a flush, and we don't support this yet, so we give it
 							// a null
 							errors_appender.Append(Value());
 						} else {
-							errors_appender.Append(error.byte_position + 1);
+							errors_appender.Append(error.byte_position.GetIndex() + 1);
 						}
 						// 6. Column Index
 						if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) {

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

@@ -87,7 +87,7 @@ CSVError::CSVError(string error_message_p, CSVErrorType type_p, LinesPerBoundary
 }
 
 CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, string csv_row_p,
-                   LinesPerBoundary error_info_p, idx_t row_byte_position, int64_t byte_position_p,
+                   LinesPerBoundary error_info_p, idx_t row_byte_position, optional_idx byte_position_p,
                    const CSVReaderOptions &reader_options, const string &fixes)
     : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), csv_row(std::move(csv_row_p)),
       error_info(error_info_p), row_byte_position(row_byte_position), byte_position(byte_position_p) {
@@ -129,7 +129,7 @@ void CSVError::RemoveNewLine(string &error) {
 
 CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx,
                              string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position,
-                             int64_t byte_position, LogicalTypeId type) {
+                             optional_idx byte_position, LogicalTypeId type) {
 	std::ostringstream error;
 	// Which column
 	error << "Error when converting column \"" << column_name << "\". ";
@@ -192,7 +192,7 @@ CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options, LinesPerBoun
 
 CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column,
                                            LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-                                           int64_t byte_position) {
+                                           optional_idx byte_position) {
 	std::ostringstream error;
 	error << "Value with unterminated quote found." << '\n';
 	std::ostringstream how_to_fix_it;
@@ -203,7 +203,7 @@ CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, idx_
 
 CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, idx_t actual_columns,
                                               LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
-                                              int64_t byte_position) {
+                                              optional_idx byte_position) {
 	std::ostringstream error;
 	// We don't have a fix for this
 	std::ostringstream how_to_fix_it;
@@ -218,15 +218,15 @@ CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, i
 	error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns + 1;
 	if (actual_columns >= options.dialect_options.num_cols) {
 		return CSVError(error.str(), CSVErrorType::TOO_MANY_COLUMNS, actual_columns, csv_row, error_info,
-		                row_byte_position, byte_position - 1, options, how_to_fix_it.str());
+		                row_byte_position, byte_position.GetIndex() - 1, options, how_to_fix_it.str());
 	} else {
 		return CSVError(error.str(), CSVErrorType::TOO_FEW_COLUMNS, actual_columns, csv_row, error_info,
-		                row_byte_position, byte_position - 1, options, how_to_fix_it.str());
+		                row_byte_position, byte_position.GetIndex() - 1, options, how_to_fix_it.str());
 	}
 }
 
 CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
-                               string &csv_row, idx_t row_byte_position, int64_t byte_position) {
+                               string &csv_row, idx_t row_byte_position, optional_idx byte_position) {
 	std::ostringstream error;
 	// How many columns were expected and how many were found
 	error << "Invalid unicode (byte sequence mismatch) detected." << '\n';

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

@@ -90,11 +90,14 @@ void CSVReaderOptions::SetEscape(const string &input) {
 }
 
 int64_t CSVReaderOptions::GetSkipRows() const {
-	return this->dialect_options.skip_rows.GetValue();
+	return NumericCast<int64_t>(this->dialect_options.skip_rows.GetValue());
 }
 
 void CSVReaderOptions::SetSkipRows(int64_t skip_rows) {
-	dialect_options.skip_rows.Set(skip_rows);
+	if (skip_rows < 0) {
+		throw InvalidInputException("skip_rows option from read_csv scanner, must be equal or higher than 0");
+	}
+	dialect_options.skip_rows.Set(NumericCast<idx_t>(skip_rows));
 }
 
 string CSVReaderOptions::GetDelimiter() const {
@@ -141,6 +144,10 @@ void CSVReaderOptions::SetNewline(const string &input) {
 	}
 }
 
+bool CSVReaderOptions::IgnoreErrors() const {
+	return ignore_errors.GetValue() && !store_rejects.GetValue();
+}
+
 void CSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, bool read_format) {
 	string error;
 	if (read_format) {
@@ -148,7 +155,7 @@ void CSVReaderOptions::SetDateFormat(LogicalTypeId type, const string &format, b
 		error = StrTimeFormat::ParseFormatSpecifier(format, strpformat);
 		dialect_options.date_format[type].Set(strpformat);
 	} else {
-		error = StrTimeFormat::ParseFormatSpecifier(format, write_date_format[type]);
+		write_date_format[type] = Value(format);
 	}
 	if (!error.empty()) {
 		throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
@@ -162,7 +169,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 	if (loption == "auto_detect") {
 		auto_detect = ParseBoolean(value, loption);
 	} else if (loption == "sample_size") {
-		int64_t sample_size_option = ParseInteger(value, loption);
+		auto sample_size_option = ParseInteger(value, loption);
 		if (sample_size_option < 1 && sample_size_option != -1) {
 			throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
 		}
@@ -170,7 +177,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 			// If -1, we basically read the whole thing
 			sample_size_chunks = NumericLimits<idx_t>().Maximum();
 		} else {
-			sample_size_chunks = sample_size_option / STANDARD_VECTOR_SIZE;
+			sample_size_chunks = NumericCast<idx_t>(sample_size_option / STANDARD_VECTOR_SIZE);
 			if (sample_size_option % STANDARD_VECTOR_SIZE != 0) {
 				sample_size_chunks++;
 			}
@@ -179,7 +186,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 	} else if (loption == "skip") {
 		SetSkipRows(ParseInteger(value, loption));
 	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
-		maximum_line_size = ParseInteger(value, loption);
+		maximum_line_size = NumericCast<idx_t>(ParseInteger(value, loption));
 	} else if (loption == "date_format" || loption == "dateformat") {
 		string format = ParseString(value, loption);
 		SetDateFormat(LogicalTypeId::DATE, format, true);
@@ -189,7 +196,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 	} else if (loption == "ignore_errors") {
 		ignore_errors.Set(ParseBoolean(value, loption));
 	} else if (loption == "buffer_size") {
-		buffer_size = ParseInteger(value, loption);
+		buffer_size = NumericCast<idx_t>(ParseInteger(value, loption));
 		if (buffer_size == 0) {
 			throw InvalidInputException("Buffer Size option must be higher than 0");
 		}
@@ -233,11 +240,11 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 		}
 		rejects_scan_name.Set(table_name);
 	} else if (loption == "rejects_limit") {
-		int64_t limit = ParseInteger(value, loption);
+		auto limit = ParseInteger(value, loption);
 		if (limit < 0) {
 			throw BinderException("Unsupported parameter for REJECTS_LIMIT: cannot be negative");
 		}
-		rejects_limit = limit;
+		rejects_limit = NumericCast<idx_t>(limit);
 	} else {
 		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
 	}
@@ -412,12 +419,12 @@ static Value StringVectorToValue(const vector<string> &vec) {
 static uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
 	//! Const ht with accepted auto_types and their weights in specificity
 	const duckdb::unordered_map<uint8_t, uint8_t> auto_type_candidates_specificity {
-	    {(uint8_t)LogicalTypeId::VARCHAR, 0},  {(uint8_t)LogicalTypeId::TIMESTAMP, 1},
-	    {(uint8_t)LogicalTypeId::DATE, 2},     {(uint8_t)LogicalTypeId::TIME, 3},
-	    {(uint8_t)LogicalTypeId::DOUBLE, 4},   {(uint8_t)LogicalTypeId::FLOAT, 5},
-	    {(uint8_t)LogicalTypeId::DECIMAL, 6},  {(uint8_t)LogicalTypeId::BIGINT, 7},
-	    {(uint8_t)LogicalTypeId::INTEGER, 8},  {(uint8_t)LogicalTypeId::SMALLINT, 9},
-	    {(uint8_t)LogicalTypeId::TINYINT, 10}, {(uint8_t)LogicalTypeId::BOOLEAN, 11},
+	    {(uint8_t)LogicalTypeId::VARCHAR, 0},   {(uint8_t)LogicalTypeId::DOUBLE, 1},
+	    {(uint8_t)LogicalTypeId::FLOAT, 2},     {(uint8_t)LogicalTypeId::DECIMAL, 3},
+	    {(uint8_t)LogicalTypeId::BIGINT, 4},    {(uint8_t)LogicalTypeId::INTEGER, 5},
+	    {(uint8_t)LogicalTypeId::SMALLINT, 6},  {(uint8_t)LogicalTypeId::TINYINT, 7},
+	    {(uint8_t)LogicalTypeId::TIMESTAMP, 8}, {(uint8_t)LogicalTypeId::DATE, 9},
+	    {(uint8_t)LogicalTypeId::TIME, 10},     {(uint8_t)LogicalTypeId::BOOLEAN, 11},
 	    {(uint8_t)LogicalTypeId::SQLNULL, 12}};
 
 	auto id = (uint8_t)candidate_type.id();
@@ -441,7 +448,7 @@ void CSVReaderOptions::FromNamedParameters(named_parameter_map_t &in, ClientCont
                                            vector<LogicalType> &return_types, vector<string> &names) {
 	map<string, string> ordered_user_defined_parameters;
 	for (auto &kv : in) {
-		if (MultiFileReader::ParseOption(kv.first, kv.second, file_options, context)) {
+		if (MultiFileReader().ParseOption(kv.first, kv.second, file_options, context)) {
 			continue;
 		}
 		auto loption = StringUtil::Lower(kv.first);
@@ -582,17 +589,19 @@ void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) {
 	if (header.IsSetByUser()) {
 		named_params["header"] = Value(GetHeader());
 	}
-	named_params["max_line_size"] = Value::BIGINT(maximum_line_size);
+	named_params["max_line_size"] = Value::BIGINT(NumericCast<int64_t>(maximum_line_size));
 	if (dialect_options.skip_rows.IsSetByUser()) {
 		named_params["skip"] = Value::BIGINT(GetSkipRows());
 	}
 	named_params["null_padding"] = Value::BOOLEAN(null_padding);
 	named_params["parallel"] = Value::BOOLEAN(parallel);
-	if (!date_format.at(LogicalType::DATE).format_specifier.empty()) {
-		named_params["dateformat"] = Value(date_format.at(LogicalType::DATE).format_specifier);
+	if (!dialect_options.date_format.at(LogicalType::DATE).GetValue().format_specifier.empty()) {
+		named_params["dateformat"] =
+		    Value(dialect_options.date_format.at(LogicalType::DATE).GetValue().format_specifier);
 	}
-	if (!date_format.at(LogicalType::TIMESTAMP).format_specifier.empty()) {
-		named_params["timestampformat"] = Value(date_format.at(LogicalType::TIMESTAMP).format_specifier);
+	if (!dialect_options.date_format.at(LogicalType::TIMESTAMP).GetValue().format_specifier.empty()) {
+		named_params["timestampformat"] =
+		    Value(dialect_options.date_format.at(LogicalType::TIMESTAMP).GetValue().format_specifier);
 	}
 
 	named_params["normalize_names"] = Value::BOOLEAN(normalize_names);
@@ -600,7 +609,7 @@ void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) {
 		named_params["column_names"] = StringVectorToValue(name_list);
 	}
 	named_params["all_varchar"] = Value::BOOLEAN(all_varchar);
-	named_params["maximum_line_size"] = Value::BIGINT(maximum_line_size);
+	named_params["maximum_line_size"] = Value::BIGINT(NumericCast<int64_t>(maximum_line_size));
 }
 
 } // namespace duckdb

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

@@ -55,7 +55,7 @@ SinkCombineResultType PhysicalBufferedCollector::Combine(ExecutionContext &conte
 unique_ptr<GlobalSinkState> PhysicalBufferedCollector::GetGlobalSinkState(ClientContext &context) const {
 	auto state = make_uniq<BufferedCollectorGlobalState>();
 	state->context = context.shared_from_this();
-	state->buffered_data = make_shared<SimpleBufferedData>(state->context);
+	state->buffered_data = make_shared_ptr<SimpleBufferedData>(state->context);
 	return std::move(state);
 }
 

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

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

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

@@ -3,10 +3,32 @@
 
 namespace duckdb {
 
+static void InstallFromRepository(ClientContext &context, const LoadInfo &info) {
+	ExtensionRepository repository;
+	if (!info.repository.empty() && info.repo_is_alias) {
+		auto repository_url = ExtensionRepository::TryGetRepositoryUrl(info.repository);
+		// This has been checked during bind, so it should not fail here
+		if (repository_url.empty()) {
+			throw InternalException("The repository alias failed to resolve");
+		}
+		repository = ExtensionRepository(info.repository, repository_url);
+	} else if (!info.repository.empty()) {
+		repository = ExtensionRepository::GetRepositoryByUrl(info.repository);
+	}
+
+	ExtensionHelper::InstallExtension(context, info.filename, info.load_type == LoadType::FORCE_INSTALL, repository,
+	                                  info.version);
+}
+
 SourceResultType PhysicalLoad::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const {
 	if (info->load_type == LoadType::INSTALL || info->load_type == LoadType::FORCE_INSTALL) {
-		ExtensionHelper::InstallExtension(context.client, info->filename, info->load_type == LoadType::FORCE_INSTALL,
-		                                  info->repository);
+		if (info->repository.empty()) {
+			ExtensionHelper::InstallExtension(context.client, info->filename,
+			                                  info->load_type == LoadType::FORCE_INSTALL, nullptr, info->version);
+		} else {
+			InstallFromRepository(context.client, *info);
+		}
+
 	} else {
 		ExtensionHelper::LoadExternalExtension(context.client, info->filename);
 	}

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

@@ -17,7 +17,7 @@ public:
 			}
 			sample = make_uniq<ReservoirSamplePercentage>(allocator, percentage, options.seed);
 		} else {
-			auto size = options.sample_size.GetValue<int64_t>();
+			auto size = NumericCast<idx_t>(options.sample_size.GetValue<int64_t>());
 			if (size == 0) {
 				return;
 			}

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

@@ -0,0 +1,57 @@
+#include "duckdb/execution/operator/helper/physical_update_extensions.hpp"
+#include "duckdb/main/extension_helper.hpp"
+
+namespace duckdb {
+
+SourceResultType PhysicalUpdateExtensions::GetData(ExecutionContext &context, DataChunk &chunk,
+                                                   OperatorSourceInput &input) const {
+	auto &data = input.global_state.Cast<UpdateExtensionsGlobalState>();
+
+	if (data.offset >= data.update_result_entries.size()) {
+		// finished returning values
+		return SourceResultType::FINISHED;
+	}
+
+	idx_t count = 0;
+	while (data.offset < data.update_result_entries.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = data.update_result_entries[data.offset];
+
+		// return values:
+		idx_t col = 0;
+		// extension_name LogicalType::VARCHAR
+		chunk.SetValue(col++, count, Value(entry.extension_name));
+		// repository LogicalType::VARCHAR
+		chunk.SetValue(col++, count, Value(entry.repository));
+		// update_result
+		chunk.SetValue(col++, count, Value(EnumUtil::ToString(entry.tag)));
+		// previous_version LogicalType::VARCHAR
+		chunk.SetValue(col++, count, Value(entry.prev_version));
+		// current_version LogicalType::VARCHAR
+		chunk.SetValue(col++, count, Value(entry.installed_version));
+
+		data.offset++;
+		count++;
+	}
+	chunk.SetCardinality(count);
+
+	return data.offset >= data.update_result_entries.size() ? SourceResultType::FINISHED
+	                                                        : SourceResultType::HAVE_MORE_OUTPUT;
+}
+
+unique_ptr<GlobalSourceState> PhysicalUpdateExtensions::GetGlobalSourceState(ClientContext &context) const {
+	auto res = make_uniq<UpdateExtensionsGlobalState>();
+
+	if (info->extensions_to_update.empty()) {
+		// Update all
+		res->update_result_entries = ExtensionHelper::UpdateExtensions(context);
+	} else {
+		// Update extensions in extensions_to_update
+		for (const auto &ext : info->extensions_to_update) {
+			res->update_result_entries.emplace_back(ExtensionHelper::UpdateExtension(context, ext));
+		}
+	}
+
+	return std::move(res);
+}
+
+} // namespace duckdb

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

@@ -18,25 +18,30 @@ public:
 	idx_t const_idx;
 };
 
-OperatorResultType VerifyEmitConstantVectors(DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
+OperatorResultType VerifyEmitConstantVectors(const DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
 	auto &state = state_p.Cast<VerifyVectorState>();
 	D_ASSERT(state.const_idx < input.size());
 
+	// Ensure that we don't alter the input data while another thread is still using it.
+	DataChunk copied_input;
+	copied_input.Initialize(Allocator::DefaultAllocator(), input.GetTypes());
+	input.Copy(copied_input);
+
 	// emit constant vectors at the current index
 	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
-		ConstantVector::Reference(chunk.data[c], input.data[c], state.const_idx, 1);
+		ConstantVector::Reference(chunk.data[c], copied_input.data[c], state.const_idx, 1);
 	}
 	chunk.SetCardinality(1);
 	state.const_idx++;
-	if (state.const_idx >= input.size()) {
+	if (state.const_idx >= copied_input.size()) {
 		state.const_idx = 0;
 		return OperatorResultType::NEED_MORE_INPUT;
 	}
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
-OperatorResultType VerifyEmitDictionaryVectors(DataChunk &input, DataChunk &chunk, OperatorState &state) {
-	chunk.Reference(input);
+OperatorResultType VerifyEmitDictionaryVectors(const DataChunk &input, DataChunk &chunk, OperatorState &state) {
+	input.Copy(chunk);
 	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
 		Vector::DebugTransformToDictionary(chunk.data[c], chunk.size());
 	}
@@ -48,7 +53,7 @@ struct ConstantOrSequenceInfo {
 	bool is_constant = true;
 };
 
-OperatorResultType VerifyEmitSequenceVector(DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
+OperatorResultType VerifyEmitSequenceVector(const DataChunk &input, DataChunk &chunk, OperatorState &state_p) {
 	auto &state = state_p.Cast<VerifyVectorState>();
 	D_ASSERT(state.const_idx < input.size());
 
@@ -189,8 +194,8 @@ OperatorResultType VerifyEmitSequenceVector(DataChunk &input, DataChunk &chunk,
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
-OperatorResultType VerifyEmitNestedShuffleVector(DataChunk &input, DataChunk &chunk, OperatorState &state) {
-	chunk.Reference(input);
+OperatorResultType VerifyEmitNestedShuffleVector(const DataChunk &input, DataChunk &chunk, OperatorState &state) {
+	input.Copy(chunk);
 	for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
 		Vector::DebugShuffleNestedVector(chunk.data[c], chunk.size());
 	}

package/src/duckdb/src/execution/operator/join/physical_asof_join.cpp

@@ -159,7 +159,7 @@ SinkFinalizeType PhysicalAsOfJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 	// The data is all in so we can initialise the left partitioning.
 	const vector<unique_ptr<BaseStatistics>> partitions_stats;
 	gstate.lhs_sink = make_uniq<PartitionGlobalSinkState>(context, lhs_partitions, lhs_orders, children[0]->types,
-	                                                      partitions_stats, 0);
+	                                                      partitions_stats, 0U);
 	gstate.lhs_sink->SyncPartitioning(gstate.rhs_sink);
 
 	// Find the first group to sort
@@ -169,7 +169,7 @@ SinkFinalizeType PhysicalAsOfJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 	}
 
 	// Schedule all the sorts for maximum thread utilisation
-	auto new_event = make_shared<PartitionMergeEvent>(gstate.rhs_sink, pipeline);
+	auto new_event = make_shared_ptr<PartitionMergeEvent>(gstate.rhs_sink, pipeline);
 	event.InsertEvent(std::move(new_event));
 
 	return SinkFinalizeType::READY;