duckdb 1.1.0 → 1.1.1-dev3.0

package/src/duckdb/src/common/http_util.cpp

@@ -6,7 +6,11 @@
 namespace duckdb {
 
 void HTTPUtil::ParseHTTPProxyHost(string &proxy_value, string &hostname_out, idx_t &port_out, idx_t default_port) {
-	auto proxy_split = StringUtil::Split(proxy_value, ":");
+	auto sanitized_proxy_value = proxy_value;
+	if (StringUtil::StartsWith(proxy_value, "http://")) {
+		sanitized_proxy_value = proxy_value.substr(7);
+	}
+	auto proxy_split = StringUtil::Split(sanitized_proxy_value, ":");
 	if (proxy_split.size() == 1) {
 		hostname_out = proxy_split[0];
 		port_out = default_port;

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -920,68 +920,12 @@ bool TryCast::Operation(double input, double &result, bool strict) {
 //===--------------------------------------------------------------------===//
 // Cast String -> Numeric
 //===--------------------------------------------------------------------===//
+
 template <>
 bool TryCast::Operation(string_t input, bool &result, bool strict) {
-	auto input_data = reinterpret_cast<const uint8_t *>(input.GetData());
+	auto input_data = reinterpret_cast<const char *>(input.GetData());
 	auto input_size = input.GetSize();
-
-	switch (input_size) {
-	case 1: {
-		unsigned char c = UnsafeNumericCast<uint8_t>(std::tolower(*input_data));
-		if (c == 't' || (!strict && c == 'y') || (!strict && c == '1')) {
-			result = true;
-			return true;
-		} else if (c == 'f' || (!strict && c == 'n') || (!strict && c == '0')) {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	case 2: {
-		unsigned char n = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char o = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
-		if (n == 'n' && o == 'o') {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	case 3: {
-		unsigned char y = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char s = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
-		if (y == 'y' && e == 'e' && s == 's') {
-			result = true;
-			return true;
-		}
-		return false;
-	}
-	case 4: {
-		unsigned char t = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char r = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char u = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
-		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[3]));
-		if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
-			result = true;
-			return true;
-		}
-		return false;
-	}
-	case 5: {
-		unsigned char f = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
-		unsigned char a = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
-		unsigned char l = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
-		unsigned char s = UnsafeNumericCast<uint8_t>(std::tolower(input_data[3]));
-		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[4]));
-		if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
-			result = false;
-			return true;
-		}
-		return false;
-	}
-	default:
-		return false;
-	}
+	return TryCastStringBool(input_data, input_size, result, strict);
 }
 template <>
 bool TryCast::Operation(string_t input, int8_t &result, bool strict) {
@@ -2298,7 +2242,9 @@ bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParame
 template <class SRC, class DST>
 bool DoubleToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale];
-	if (value <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] || value >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
+	double roundedValue = round(value);
+	if (roundedValue <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] ||
+	    roundedValue >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
 		string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", value, width, scale);
 		HandleCastError::AssignError(error, parameters);
 		return false;

package/src/duckdb/src/common/types/bit.cpp

@@ -180,7 +180,7 @@ void Bit::BitToBlob(string_t bit, string_t &output_blob) {
 	idx_t size = output_blob.GetSize();
 
 	output[0] = UnsafeNumericCast<char>(GetFirstByte(bit));
-	if (size > 2) {
+	if (size >= 2) {
 		++output;
 		// First byte in bitstring contains amount of padded bits,
 		// second byte in bitstring is the padded byte,

package/src/duckdb/src/common/types/column/column_data_allocator.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/types/column/column_data_collection_segment.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 
 namespace duckdb {
@@ -45,6 +46,21 @@ ColumnDataAllocator::ColumnDataAllocator(ColumnDataAllocator &other) {
 	}
 }
 
+ColumnDataAllocator::~ColumnDataAllocator() {
+	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
+		return;
+	}
+	for (auto &block : blocks) {
+		block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
+	}
+	const auto data_size = SizeInBytes();
+	blocks.clear();
+	if (Allocator::SupportsFlush() &&
+	    data_size > alloc.buffer_manager->GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
+		Allocator::FlushAll();
+	}
+}
+
 BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {
 	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
 	shared_ptr<BlockHandle> handle;
@@ -65,7 +81,8 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 	BlockMetaData data;
 	data.size = 0;
 	data.capacity = NumericCast<uint32_t>(max_size);
-	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, max_size, false, &data.handle);
+	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, max_size, false);
+	data.handle = pin.GetBlockHandle();
 	blocks.push_back(std::move(data));
 	allocated_size += max_size;
 	return pin;

package/src/duckdb/src/common/types/row/tuple_data_allocator.cpp

@@ -11,7 +11,8 @@ namespace duckdb {
 using ValidityBytes = TupleDataLayout::ValidityBytes;
 
 TupleDataBlock::TupleDataBlock(BufferManager &buffer_manager, idx_t capacity_p) : capacity(capacity_p), size(0) {
-	buffer_manager.Allocate(MemoryTag::HASH_TABLE, capacity, false, &handle);
+	auto buffer_handle = buffer_manager.Allocate(MemoryTag::HASH_TABLE, capacity, false);
+	handle = buffer_handle.GetBlockHandle();
 }
 
 TupleDataBlock::TupleDataBlock(TupleDataBlock &&other) noexcept : capacity(0), size(0) {

package/src/duckdb/src/common/types/row/tuple_data_segment.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/common/types/row/tuple_data_segment.hpp"
 
 #include "duckdb/common/types/row/tuple_data_allocator.hpp"
+#include "duckdb/storage/buffer/buffer_pool.hpp"
 
 namespace duckdb {
 
@@ -118,6 +119,10 @@ TupleDataSegment::~TupleDataSegment() {
 	}
 	pinned_row_handles.clear();
 	pinned_heap_handles.clear();
+	if (Allocator::SupportsFlush() && allocator &&
+	    data_size > allocator->GetBufferManager().GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) {
+		Allocator::FlushAll();
+	}
 	allocator.reset();
 }
 

package/src/duckdb/src/core_functions/aggregate/distributive/arg_min_max.cpp

@@ -192,7 +192,7 @@ struct GenericArgMinMaxState {
 
 	static void PrepareData(Vector &by, idx_t count, Vector &extra_state, UnifiedVectorFormat &result) {
 		OrderModifiers modifiers(ORDER_TYPE, OrderByNullType::NULLS_LAST);
-		CreateSortKeyHelpers::CreateSortKey(by, count, modifiers, extra_state);
+		CreateSortKeyHelpers::CreateSortKeyWithValidity(by, extra_state, modifiers, count);
 		extra_state.ToUnifiedFormat(count, result);
 	}
 };

package/src/duckdb/src/core_functions/aggregate/distributive/minmax.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/main/config.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
@@ -330,7 +331,7 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
                                     vector<unique_ptr<Expression>> &arguments) {
 	if (arguments[0]->return_type.id() == LogicalTypeId::VARCHAR) {
 		auto str_collation = StringType::GetCollation(arguments[0]->return_type);
-		if (!str_collation.empty()) {
+		if (!str_collation.empty() || !DBConfig::GetConfig(context).options.collation.empty()) {
 			// If aggr function is min/max and uses collations, replace bound_function with arg_min/arg_max
 			// to make sure the result's correctness.
 			string function_name = function.name == "min" ? "arg_min" : "arg_max";

package/src/duckdb/src/execution/index/art/iterator.cpp

@@ -251,11 +251,7 @@ bool Iterator::Next() {
 }
 
 void Iterator::PopNode() {
-	// We are popping a gate node.
-	if (nodes.top().node.GetGateStatus() == GateStatus::GATE_SET) {
-		D_ASSERT(status == GateStatus::GATE_SET);
-		status = GateStatus::GATE_NOT_SET;
-	}
+	auto gate_status = nodes.top().node.GetGateStatus();
 
 	// Pop the byte and the node.
 	if (nodes.top().node.GetType() != NType::PREFIX) {
@@ -264,19 +260,25 @@ void Iterator::PopNode() {
 			nested_depth--;
 			D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
 		}
-		nodes.pop();
-		return;
-	}
 
-	// Pop all prefix bytes and the node.
-	Prefix prefix(art, nodes.top().node);
-	auto prefix_byte_count = prefix.data[Prefix::Count(art)];
-	current_key.Pop(prefix_byte_count);
-	if (status == GateStatus::GATE_SET) {
-		nested_depth -= prefix_byte_count;
-		D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
+	} else {
+		// Pop all prefix bytes and the node.
+		Prefix prefix(art, nodes.top().node);
+		auto prefix_byte_count = prefix.data[Prefix::Count(art)];
+		current_key.Pop(prefix_byte_count);
+
+		if (status == GateStatus::GATE_SET) {
+			nested_depth -= prefix_byte_count;
+			D_ASSERT(nested_depth < Prefix::ROW_ID_SIZE);
+		}
 	}
 	nodes.pop();
+
+	// We are popping a gate node.
+	if (gate_status == GateStatus::GATE_SET) {
+		D_ASSERT(status == GateStatus::GATE_SET);
+		status = GateStatus::GATE_NOT_SET;
+	}
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -400,42 +400,15 @@ void Prefix::TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<Fixed
 		return Node::TransformToDeprecated(art, ref, allocator);
 	}
 
-	// Fast path.
-	if (art.prefix_count <= DEPRECATED_COUNT) {
-		reference<Node> ref(node);
-		while (ref.get().GetType() == PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-			Prefix prefix(art, ref, true, true);
-			if (!prefix.in_memory) {
-				return;
-			}
-
-			Node new_node;
-			new_node = allocator->New();
-			new_node.SetMetadata(static_cast<uint8_t>(PREFIX));
-
-			Prefix new_prefix(allocator, new_node, DEPRECATED_COUNT);
-			new_prefix.data[DEPRECATED_COUNT] = prefix.data[Count(art)];
-			memcpy(new_prefix.data, prefix.data, new_prefix.data[DEPRECATED_COUNT]);
-			*new_prefix.ptr = *prefix.ptr;
-
-			prefix.ptr->Clear();
-			Node::Free(art, ref);
-			ref.get() = new_node;
-			ref = *new_prefix.ptr;
-		}
-
-		return Node::TransformToDeprecated(art, ref, allocator);
-	}
-
-	// Else, we need to create a new prefix chain.
+	// We need to create a new prefix (chain).
 	Node new_node;
 	new_node = allocator->New();
 	new_node.SetMetadata(static_cast<uint8_t>(PREFIX));
 	Prefix new_prefix(allocator, new_node, DEPRECATED_COUNT);
 
-	reference<Node> ref(node);
-	while (ref.get().GetType() == PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) {
-		Prefix prefix(art, ref, true, true);
+	Node current_node = node;
+	while (current_node.GetType() == PREFIX && current_node.GetGateStatus() == GateStatus::GATE_NOT_SET) {
+		Prefix prefix(art, current_node, true, true);
 		if (!prefix.in_memory) {
 			return;
 		}
@@ -445,11 +418,13 @@ void Prefix::TransformToDeprecated(ART &art, Node &node, unsafe_unique_ptr<Fixed
 		}
 
 		*new_prefix.ptr = *prefix.ptr;
-		Node::GetAllocator(art, PREFIX).Free(ref);
-		ref = *new_prefix.ptr;
+		prefix.ptr->Clear();
+		Node::Free(art, current_node);
+		current_node = *new_prefix.ptr;
 	}
 
-	return Node::TransformToDeprecated(art, ref, allocator);
+	node = new_node;
+	return Node::TransformToDeprecated(art, *new_prefix.ptr, allocator);
 }
 
 Prefix Prefix::Append(ART &art, const uint8_t byte) {

package/src/duckdb/src/execution/index/fixed_size_buffer.cpp

@@ -40,7 +40,8 @@ FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager)
       block_handle(nullptr) {
 
 	auto &buffer_manager = block_manager.buffer_manager;
-	buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false, &block_handle);
+	buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false);
+	block_handle = buffer_handle.GetBlockHandle();
 }
 
 FixedSizeBuffer::FixedSizeBuffer(BlockManager &block_manager, const idx_t segment_count, const idx_t allocation_size,
@@ -137,8 +138,8 @@ void FixedSizeBuffer::Pin() {
 
 	// Copy the (partial) data into a new (not yet disk-backed) buffer handle.
 	shared_ptr<BlockHandle> new_block_handle;
-	auto new_buffer_handle =
-	    buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false, &new_block_handle);
+	auto new_buffer_handle = buffer_manager.Allocate(MemoryTag::ART_INDEX, block_manager.GetBlockSize(), false);
+	new_block_handle = new_buffer_handle.GetBlockHandle();
 	memcpy(new_buffer_handle.Ptr(), buffer_handle.Ptr() + block_pointer.offset, allocation_size);
 
 	buffer_handle = std::move(new_buffer_handle);

package/src/duckdb/src/execution/operator/aggregate/physical_ungrouped_aggregate.cpp

@@ -342,6 +342,7 @@ void LocalUngroupedAggregateState::Sink(DataChunk &payload_chunk, idx_t payload_
 #endif
 	auto &aggregate = state.aggregate_expressions[aggr_idx]->Cast<BoundAggregateExpression>();
 	idx_t payload_cnt = aggregate.children.size();
+	D_ASSERT(payload_idx + payload_cnt <= payload_chunk.data.size());
 	auto start_of_input = payload_cnt == 0 ? nullptr : &payload_chunk.data[payload_idx];
 	AggregateInputData aggr_input_data(state.bind_data[aggr_idx], allocator);
 	aggregate.function.simple_update(start_of_input, aggr_input_data, payload_cnt, state.aggregate_data[aggr_idx].get(),

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

@@ -54,7 +54,8 @@ void CSVBuffer::AllocateBuffer(idx_t buffer_size) {
 	auto &buffer_manager = BufferManager::GetBufferManager(context);
 	bool can_destroy = !is_pipe;
 	handle = buffer_manager.Allocate(MemoryTag::CSV_READER, MaxValue<idx_t>(buffer_manager.GetBlockSize(), buffer_size),
-	                                 can_destroy, &block);
+	                                 can_destroy);
+	block = handle.GetBlockHandle();
 }
 
 idx_t CSVBuffer::GetBufferSize() {

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

@@ -25,7 +25,7 @@ BaseScanner::BaseScanner(shared_ptr<CSVBufferManager> buffer_manager_p, shared_p
 	}
 }
 
-bool BaseScanner::FinishedFile() {
+bool BaseScanner::FinishedFile() const {
 	if (!cur_buffer_handle) {
 		return true;
 	}
@@ -76,7 +76,7 @@ void BaseScanner::FinalizeChunkProcess() {
 	throw InternalException("FinalizeChunkProcess() from CSV Base Scanner is not implemented");
 }
 
-CSVStateMachine &BaseScanner::GetStateMachine() {
+CSVStateMachine &BaseScanner::GetStateMachine() const {
 	return *state_machine;
 }
 

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

@@ -12,10 +12,32 @@ void ColumnCountResult::AddValue(ColumnCountResult &result, idx_t buffer_pos) {
 }
 
 inline void ColumnCountResult::InternalAddRow() {
-	column_counts[result_position].number_of_columns = current_column_count + 1;
+	const idx_t column_count = current_column_count + 1;
+	column_counts[result_position].number_of_columns = column_count;
+	rows_per_column_count[column_count]++;
 	current_column_count = 0;
 }
 
+idx_t ColumnCountResult::GetMostFrequentColumnCount() const {
+	if (rows_per_column_count.empty()) {
+		return 1;
+	}
+	idx_t column_count = 0;
+	idx_t current_max = 0;
+	for (auto &rpc : rows_per_column_count) {
+		if (rpc.second > current_max) {
+			current_max = rpc.second;
+			column_count = rpc.first;
+		} else if (rpc.second == current_max) {
+			// We pick the largest to untie
+			if (rpc.first > column_count) {
+				column_count = rpc.first;
+			}
+		}
+	}
+	return column_count;
+}
+
 bool ColumnCountResult::AddRow(ColumnCountResult &result, idx_t buffer_pos) {
 	result.InternalAddRow();
 	if (!result.states.EmptyLastValue()) {

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

@@ -28,6 +28,11 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m
       current_errors(state_machine.options.IgnoreErrors()), sniffing(sniffing_p), path(std::move(path_p)) {
 	// Vector information
 	D_ASSERT(number_of_columns > 0);
+	if (!buffer_handle) {
+		// It Was Over Before It Even Began
+		D_ASSERT(iterator.done);
+		return;
+	}
 	buffer_handles[buffer_handle->buffer_idx] = buffer_handle;
 	// Buffer Information
 	buffer_ptr = buffer_handle->Ptr();
@@ -264,6 +269,10 @@ void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size
 	}
 	bool success = true;
 	switch (parse_types[chunk_col_id].type_id) {
+	case LogicalTypeId::BOOLEAN:
+		success =
+		    TryCastStringBool(value_ptr, size, static_cast<bool *>(vector_ptr[chunk_col_id])[number_of_rows], false);
+		break;
 	case LogicalTypeId::TINYINT:
 		success = TrySimpleIntegerCast(value_ptr, size, static_cast<int8_t *>(vector_ptr[chunk_col_id])[number_of_rows],
 		                               false);
@@ -644,9 +653,15 @@ bool LineError::HandleErrors(StringValueResult &result) {
 		result.error_handler.Error(csv_error);
 	}
 	if (is_error_in_line) {
-		result.borked_rows.insert(result.number_of_rows);
-		result.cur_col_id = 0;
-		result.chunk_col_id = 0;
+		if (result.sniffing) {
+			// If we are sniffing we just remove the line
+			result.RemoveLastLine();
+		} else {
+			// Otherwise, we add it to the borked rows to remove it later and just cleanup the column variables.
+			result.borked_rows.insert(result.number_of_rows);
+			result.cur_col_id = 0;
+			result.chunk_col_id = 0;
+		}
 		Reset();
 		return true;
 	}
@@ -1437,6 +1452,7 @@ bool StringValueScanner::CanDirectlyCast(const LogicalType &type, bool icu_loade
 	case LogicalTypeId::TIME:
 	case LogicalTypeId::DECIMAL:
 	case LogicalType::VARCHAR:
+	case LogicalType::BOOLEAN:
 		return true;
 	case LogicalType::TIMESTAMP_TZ:
 		// We only try to do direct cast of timestamp tz if the ICU extension is not loaded, otherwise, it needs to go
@@ -1493,7 +1509,7 @@ void StringValueScanner::SetStart() {
 			}
 			if (iterator.pos.buffer_pos == cur_buffer_handle->actual_size ||
 			    scan_finder->iterator.GetBufferIdx() > iterator.GetBufferIdx()) {
-				// If things go terribly wrong, we never loop indefinetly.
+				// If things go terribly wrong, we never loop indefinitely.
 				iterator.pos.buffer_idx = scan_finder->iterator.pos.buffer_idx;
 				iterator.pos.buffer_pos = scan_finder->iterator.pos.buffer_pos;
 				result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, result.buffer_size};
@@ -1521,8 +1537,11 @@ void StringValueScanner::FinalizeChunkProcess() {
 	// If we are not done we have two options.
 	// 1) If a boundary is set.
 	if (iterator.IsBoundarySet()) {
+		bool has_unterminated_quotes = false;
 		if (!result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) {
 			iterator.done = true;
+		} else {
+			has_unterminated_quotes = true;
 		}
 		// We read until the next line or until we have nothing else to read.
 		// Move to next buffer
@@ -1540,6 +1559,16 @@ void StringValueScanner::FinalizeChunkProcess() {
 				MoveToNextBuffer();
 			}
 		} else {
+			if (result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) {
+				has_unterminated_quotes = true;
+			}
+			result.current_errors.HandleErrors(result);
+		}
+		if (states.IsQuotedCurrent() && !has_unterminated_quotes) {
+			// If we finish the execution of a buffer, and we end in a quoted state, it means we have unterminated
+			// quotes
+			result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id,
+			                             result.last_position);
 			result.current_errors.HandleErrors(result);
 		}
 		if (!iterator.done) {

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

@@ -134,7 +134,11 @@ SnifferResult CSVSniffer::MinimalSniff() {
 		for (idx_t col_idx = 0; col_idx < data_chunk.ColumnCount(); col_idx++) {
 			auto &cur_vector = data_chunk.data[col_idx];
 			auto vector_data = FlatVector::GetData<string_t>(cur_vector);
-			HeaderValue val(vector_data[0]);
+			auto &validity = FlatVector::Validity(cur_vector);
+			HeaderValue val;
+			if (validity.RowIsValid(0)) {
+				val = HeaderValue(vector_data[0]);
+			}
 			potential_header.emplace_back(val);
 		}
 	}
@@ -221,13 +225,16 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) {
 			// If the header exists it should match
 			string header_error = "The Column names set by the user do not match the ones found by the sniffer. \n";
 			auto &set_names = *set_columns.names;
-			for (idx_t i = 0; i < set_columns.Size(); i++) {
-				if (set_names[i] != names[i]) {
-					header_error += "Column at position: " + to_string(i) + " Set name: " + set_names[i] +
-					                " Sniffed Name: " + names[i] + "\n";
-					match = false;
+			if (set_names.size() == names.size()) {
+				for (idx_t i = 0; i < set_columns.Size(); i++) {
+					if (set_names[i] != names[i]) {
+						header_error += "Column at position: " + to_string(i) + " Set name: " + set_names[i] +
+						                " Sniffed Name: " + names[i] + "\n";
+						match = false;
+					}
 				}
 			}
+
 			if (!match) {
 				error += header_error;
 			}
@@ -235,15 +242,18 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) {
 		match = true;
 		string type_error = "The Column types set by the user do not match the ones found by the sniffer. \n";
 		auto &set_types = *set_columns.types;
-		for (idx_t i = 0; i < set_columns.Size(); i++) {
-			if (set_types[i] != detected_types[i]) {
-				type_error += "Column at position: " + to_string(i) + " Set type: " + set_types[i].ToString() +
-				              " Sniffed type: " + detected_types[i].ToString() + "\n";
-				detected_types[i] = set_types[i];
-				manually_set[i] = true;
-				match = false;
+		if (detected_types.size() == set_columns.Size()) {
+			for (idx_t i = 0; i < set_columns.Size(); i++) {
+				if (set_types[i] != detected_types[i]) {
+					type_error += "Column at position: " + to_string(i) + " Set type: " + set_types[i].ToString() +
+					              " Sniffed type: " + detected_types[i].ToString() + "\n";
+					detected_types[i] = set_types[i];
+					manually_set[i] = true;
+					match = false;
+				}
 			}
 		}
+
 		if (!match) {
 			error += type_error;
 		}