duckdb 0.8.2-dev2356.0 → 0.8.2-dev2509.0

package/binding.gyp

@@ -244,18 +244,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu_extension.cpp", 
-                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
-                "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
                 "src/duckdb/extension/icu/./icu-timebucket.cpp", 
                 "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu_extension.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2356.0",
+  "version": "0.8.2-dev2509.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -5,6 +5,8 @@
 #include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 
+#include "unicode/ucal.h"
+
 namespace duckdb {
 
 ICUDateFunc::BindData::BindData(const BindData &other)
@@ -34,6 +36,13 @@ ICUDateFunc::BindData::BindData(ClientContext &context) {
 	if (U_FAILURE(success)) {
 		throw Exception("Unable to create ICU calendar.");
 	}
+
+	//	Postgres always assumes times are given in the proleptic Gregorian calendar.
+	//	ICU defaults to the Gregorian change in 1582, so we reset the change to the minimum date
+	//	so that all dates are proleptic Gregorian.
+	//	The only error here is if we have a non-Gregorian calendar,
+	//	and we just ignore that and hope for the best...
+	ucal_setGregorianChange((UCalendar *)calendar.get(), U_DATE_MIN, &success); // NOLINT
 }
 
 bool ICUDateFunc::BindData::Equals(const FunctionData &other_p) const {

package/src/duckdb/extension/icu/icu-datepart.cpp

@@ -109,11 +109,8 @@ struct ICUDatePart : public ICUDateFunc {
 
 	static int64_t ExtractEpoch(icu::Calendar *calendar, const uint64_t micros) {
 		UErrorCode status = U_ZERO_ERROR;
-		auto millis = calendar->getTime(status);
-		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
-		millis += ExtractField(calendar, UCAL_DST_OFFSET);
 		//	Truncate
-		return millis / Interval::MSECS_PER_SEC;
+		return calendar->getTime(status) / Interval::MSECS_PER_SEC;
 	}
 
 	static int64_t ExtractTimezone(icu::Calendar *calendar, const uint64_t micros) {
@@ -200,7 +197,12 @@ struct ICUDatePart : public ICUDateFunc {
 
 		calendar->set(UCAL_DATE, dd);
 
-		return Date::EpochToDate(ExtractEpoch(calendar, 0));
+		//	Offset to UTC
+		auto millis = calendar->getTime(status);
+		millis += ExtractField(calendar, UCAL_ZONE_OFFSET);
+		millis += ExtractField(calendar, UCAL_DST_OFFSET);
+
+		return Date::EpochToDate(millis / Interval::MSECS_PER_SEC);
 	}
 
 	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {

package/src/duckdb/extension/icu/icu-strptime.cpp

@@ -273,26 +273,7 @@ struct ICUStrptime : public ICUDateFunc {
 				    }
 
 				    // Now get the parts in the given time zone
-				    date_t d;
-				    dtime_t t;
-				    Timestamp::Convert(result, d, t);
-
-				    int32_t data[7];
-				    Date::Convert(d, data[0], data[1], data[2]);
-				    calendar->set(UCAL_EXTENDED_YEAR, data[0]); // strptime doesn't understand eras
-				    calendar->set(UCAL_MONTH, data[1] - 1);
-				    calendar->set(UCAL_DATE, data[2]);
-
-				    Time::Convert(t, data[3], data[4], data[5], data[6]);
-				    calendar->set(UCAL_HOUR_OF_DAY, data[3]);
-				    calendar->set(UCAL_MINUTE, data[4]);
-				    calendar->set(UCAL_SECOND, data[5]);
-
-				    int32_t millis = data[6] / Interval::MICROS_PER_MSEC;
-				    uint64_t micros = data[6] % Interval::MICROS_PER_MSEC;
-				    calendar->set(UCAL_MILLISECOND, millis);
-
-				    result = GetTime(calendar, micros);
+				    result = FromNaive(calendar, result);
 			    }
 
 			    return result;

package/src/duckdb/src/common/http_state.cpp

@@ -0,0 +1,78 @@
+#include "duckdb/common/http_state.hpp"
+
+namespace duckdb {
+
+CachedFileHandle::CachedFileHandle(shared_ptr<CachedFile> &file_p) {
+	// If the file was not yet initialized, we need to grab a lock.
+	if (!file_p->initialized) {
+		lock = make_uniq<lock_guard<mutex>>(file_p->lock);
+	}
+	file = file_p;
+}
+
+void CachedFileHandle::SetInitialized() {
+	if (file->initialized) {
+		throw InternalException("Cannot set initialized on cached file that was already initialized");
+	}
+	if (!lock) {
+		throw InternalException("Cannot set initialized on cached file without lock");
+	}
+	file->initialized = true;
+	lock = nullptr;
+}
+
+void CachedFileHandle::AllocateBuffer(idx_t size) {
+	if (file->initialized) {
+		throw InternalException("Cannot allocate a buffer for a cached file that was already initialized");
+	}
+	file->data = std::shared_ptr<char>(new char[size], std::default_delete<char[]>());
+	file->capacity = size;
+}
+
+void CachedFileHandle::GrowBuffer(idx_t new_capacity, idx_t bytes_to_copy) {
+	// copy shared ptr to old data
+	auto old_data = file->data;
+	// allocate new buffer that can hold the new capacity
+	AllocateBuffer(new_capacity);
+	// copy the old data
+	Write(old_data.get(), bytes_to_copy);
+}
+
+void CachedFileHandle::Write(const char *buffer, idx_t length, idx_t offset) {
+	//! Only write to non-initialized files with a lock;
+	D_ASSERT(!file->initialized && lock);
+	memcpy(file->data.get() + offset, buffer, length);
+}
+
+void HTTPState::Reset() {
+	// Reset Counters
+	head_count = 0;
+	get_count = 0;
+	put_count = 0;
+	post_count = 0;
+	total_bytes_received = 0;
+	total_bytes_sent = 0;
+
+	// Reset cached files
+	cached_files.clear();
+}
+
+shared_ptr<HTTPState> HTTPState::TryGetState(FileOpener *opener) {
+	auto client_context = FileOpener::TryGetClientContext(opener);
+	if (client_context) {
+		return client_context->client_data->http_state;
+	}
+	return nullptr;
+}
+
+//! Get cache entry, create if not exists
+shared_ptr<CachedFile> &HTTPState::GetCachedFile(const string &path) {
+	lock_guard<mutex> lock(cached_files_mutex);
+	auto &cache_entry_ref = cached_files[path];
+	if (!cache_entry_ref) {
+		cache_entry_ref = make_shared<CachedFile>();
+	}
+	return cache_entry_ref;
+}
+
+} // namespace duckdb

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

@@ -96,7 +96,7 @@ static uint16_t GetCapacityForNewSegment(uint16_t capacity) {
 }
 
 //===--------------------------------------------------------------------===//
-// Create & Destroy
+// Create
 //===--------------------------------------------------------------------===//
 template <class T>
 static ListSegment *CreatePrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &allocator, uint16_t capacity) {
@@ -174,56 +174,55 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAlloc
 // Append
 //===--------------------------------------------------------------------===//
 template <class T>
-static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                        ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+static void WriteDataToPrimitiveSegment(const ListSegmentFunctions &, ArenaAllocator &, ListSegment *segment,
+                                        RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
 
-	// get the vector data and the source index of the entry that we want to write
-	auto input_data = FlatVector::GetData(input);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// write value
-	if (!is_null) {
-		auto data = GetPrimitiveData<T>(segment);
-		Store<T>(((T *)input_data)[entry_idx], data_ptr_cast(data + segment->count));
+	if (valid) {
+		auto segment_data = GetPrimitiveData<T>(segment);
+		auto input_data_ptr = UnifiedVectorFormat::GetData<T>(input_data.unified);
+		Store<T>(input_data_ptr[sel_entry_idx], data_ptr_cast(segment_data + segment->count));
 	}
 }
 
 static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                      ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                      ListSegment *segment, RecursiveUnifiedVectorFormat &input_data,
+                                      idx_t &entry_idx) {
 
-	// get the vector data and the source index of the entry that we want to write
-	auto input_data = FlatVector::GetData<string_t>(input);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// set the length of this string
 	auto str_length_data = GetListLengthData(segment);
 	uint64_t str_length = 0;
 
 	// get the string
-	string_t str_t;
-	if (!is_null) {
-		str_t = input_data[entry_idx];
-		str_length = str_t.GetSize();
+	string_t str_entry;
+	if (valid) {
+		str_entry = UnifiedVectorFormat::GetData<string_t>(input_data.unified)[sel_entry_idx];
+		str_length = str_entry.GetSize();
 	}
 
 	// we can reconstruct the offset from the length
 	Store<uint64_t>(str_length, data_ptr_cast(str_length_data + segment->count));
-
-	if (is_null) {
+	if (!valid) {
 		return;
 	}
 
 	// write the characters to the linked list of child segments
 	auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
-	for (char &c : str_t.GetString()) {
+	for (char &c : str_entry.GetString()) {
 		auto child_segment = GetSegment(functions.child_functions.back(), allocator, child_segments);
 		auto data = GetPrimitiveData<char>(child_segment);
 		data[child_segment->count] = c;
@@ -236,37 +235,31 @@ static void WriteDataToVarcharSegment(const ListSegmentFunctions &functions, Are
 }
 
 static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                   ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                   ListSegment *segment, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
 
-	// get the vector data and the source index of the entry that we want to write
-	auto input_data = FlatVector::GetData<list_entry_t>(input);
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// set the length of this list
 	auto list_length_data = GetListLengthData(segment);
 	uint64_t list_length = 0;
 
-	if (!is_null) {
+	if (valid) {
 		// get list entry information
-		auto list_entries = input_data;
-		const auto &list_entry = list_entries[entry_idx];
+		const auto &list_entry = UnifiedVectorFormat::GetData<list_entry_t>(input_data.unified)[sel_entry_idx];
 		list_length = list_entry.length;
 
-		// get the child vector and its data
-		auto lists_size = ListVector::GetListSize(input);
-		auto &child_vector = ListVector::GetEntry(input);
-
 		// loop over the child vector entries and recurse on them
 		auto child_segments = Load<LinkedList>(data_ptr_cast(GetListChildData(segment)));
 		D_ASSERT(functions.child_functions.size() == 1);
 		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
 			auto source_idx_child = list_entry.offset + child_idx;
-			functions.child_functions[0].AppendRow(allocator, child_segments, child_vector, source_idx_child,
-			                                       lists_size);
+			functions.child_functions[0].AppendRow(allocator, child_segments, input_data.children.back(),
+			                                       source_idx_child);
 		}
 		// store the updated linked list
 		Store<LinkedList>(child_segments, data_ptr_cast(GetListChildData(segment)));
@@ -276,35 +269,34 @@ static void WriteDataToListSegment(const ListSegmentFunctions &functions, ArenaA
 }
 
 static void WriteDataToStructSegment(const ListSegmentFunctions &functions, ArenaAllocator &allocator,
-                                     ListSegment *segment, Vector &input, idx_t &entry_idx, idx_t &count) {
+                                     ListSegment *segment, RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) {
+
+	auto sel_entry_idx = input_data.unified.sel->get_index(entry_idx);
 
 	// write null validity
 	auto null_mask = GetNullMask(segment);
-	auto is_null = FlatVector::IsNull(input, entry_idx);
-	null_mask[segment->count] = is_null;
+	auto valid = input_data.unified.validity.RowIsValid(sel_entry_idx);
+	null_mask[segment->count] = !valid;
 
 	// write value
-	auto &children = StructVector::GetEntries(input);
-	D_ASSERT(children.size() == functions.child_functions.size());
+	D_ASSERT(input_data.children.size() == functions.child_functions.size());
 	auto child_list = GetStructData(segment);
 
 	// write the data of each of the children of the struct
-	for (idx_t child_count = 0; child_count < children.size(); child_count++) {
-		auto child_list_segment = Load<ListSegment *>(data_ptr_cast(child_list + child_count));
-		auto &child_function = functions.child_functions[child_count];
-		child_function.write_data(child_function, allocator, child_list_segment, *children[child_count], entry_idx,
-		                          count);
+	for (idx_t i = 0; i < input_data.children.size(); i++) {
+		auto child_list_segment = Load<ListSegment *>(data_ptr_cast(child_list + i));
+		auto &child_function = functions.child_functions[i];
+		child_function.write_data(child_function, allocator, child_list_segment, input_data.children[i], entry_idx);
 		child_list_segment->count++;
 	}
 }
 
-void ListSegmentFunctions::AppendRow(ArenaAllocator &allocator, LinkedList &linked_list, Vector &input,
-                                     idx_t &entry_idx, idx_t &count) const {
+void ListSegmentFunctions::AppendRow(ArenaAllocator &allocator, LinkedList &linked_list,
+                                     RecursiveUnifiedVectorFormat &input_data, idx_t &entry_idx) const {
 
-	D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &write_data_to_segment = *this;
 	auto segment = GetSegment(write_data_to_segment, allocator, linked_list);
-	write_data_to_segment.write_data(write_data_to_segment, allocator, segment, input, entry_idx, count);
+	write_data_to_segment.write_data(write_data_to_segment, allocator, segment, input_data, entry_idx);
 
 	linked_list.total_capacity++;
 	segment->count++;
@@ -458,86 +450,6 @@ void ListSegmentFunctions::BuildListVector(const LinkedList &linked_list, Vector
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Copy
-//===--------------------------------------------------------------------===//
-template <class T>
-static ListSegment *CopyDataFromPrimitiveSegment(const ListSegmentFunctions &, const ListSegment *source,
-                                                 ArenaAllocator &allocator) {
-
-	auto target = (ListSegment *)AllocatePrimitiveData<T>(allocator, source->capacity);
-	memcpy(target, source, sizeof(ListSegment) + source->capacity * (sizeof(bool) + sizeof(T)));
-	target->next = nullptr;
-	return target;
-}
-
-static ListSegment *CopyDataFromListSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                            ArenaAllocator &allocator) {
-
-	// create an empty linked list for the child vector of target
-	auto source_linked_child_list = Load<LinkedList>(const_data_ptr_cast(GetListChildData(source)));
-
-	// create the segment
-	auto target = reinterpret_cast<ListSegment *>(AllocateListData(allocator, source->capacity));
-	memcpy(target, source,
-	       sizeof(ListSegment) + source->capacity * (sizeof(bool) + sizeof(uint64_t)) + sizeof(LinkedList));
-	target->next = nullptr;
-
-	auto target_linked_list = GetListChildData(target);
-	LinkedList linked_list(source_linked_child_list.total_capacity, nullptr, nullptr);
-	Store<LinkedList>(linked_list, data_ptr_cast(target_linked_list));
-
-	// recurse to copy the linked child list
-	auto target_linked_child_list = Load<LinkedList>(data_ptr_cast(GetListChildData(target)));
-	D_ASSERT(functions.child_functions.size() == 1);
-	functions.child_functions[0].CopyLinkedList(source_linked_child_list, target_linked_child_list, allocator);
-
-	// store the updated linked list
-	Store<LinkedList>(target_linked_child_list, data_ptr_cast(GetListChildData(target)));
-	return target;
-}
-
-static ListSegment *CopyDataFromStructSegment(const ListSegmentFunctions &functions, const ListSegment *source,
-                                              ArenaAllocator &allocator) {
-
-	auto source_child_count = functions.child_functions.size();
-	auto target = reinterpret_cast<ListSegment *>(AllocateStructData(allocator, source->capacity, source_child_count));
-	memcpy(target, source,
-	       sizeof(ListSegment) + source->capacity * sizeof(bool) + source_child_count * sizeof(ListSegment *));
-	target->next = nullptr;
-
-	// recurse and copy the children
-	auto source_child_segments = GetStructData(source);
-	auto target_child_segments = GetStructData(target);
-
-	for (idx_t i = 0; i < functions.child_functions.size(); i++) {
-		auto child_function = functions.child_functions[i];
-		auto source_child_segment = Load<ListSegment *>(const_data_ptr_cast(source_child_segments + i));
-		auto target_child_segment = child_function.copy_data(child_function, source_child_segment, allocator);
-		Store<ListSegment *>(target_child_segment, data_ptr_cast(target_child_segments + i));
-	}
-	return target;
-}
-
-void ListSegmentFunctions::CopyLinkedList(const LinkedList &source_list, LinkedList &target_list,
-                                          ArenaAllocator &allocator) const {
-	auto &copy_data_from_segment = *this;
-	auto source_segment = source_list.first_segment;
-
-	while (source_segment) {
-		auto target_segment = copy_data_from_segment.copy_data(copy_data_from_segment, source_segment, allocator);
-		source_segment = source_segment->next;
-
-		if (!target_list.first_segment) {
-			target_list.first_segment = target_segment;
-		}
-		if (target_list.last_segment) {
-			target_list.last_segment->next = target_segment;
-		}
-		target_list.last_segment = target_segment;
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // Functions
 //===--------------------------------------------------------------------===//
@@ -546,7 +458,6 @@ void SegmentPrimitiveFunction(ListSegmentFunctions &functions) {
 	functions.create_segment = CreatePrimitiveSegment<T>;
 	functions.write_data = WriteDataToPrimitiveSegment<T>;
 	functions.read_data = ReadDataFromPrimitiveSegment<T>;
-	functions.copy_data = CopyDataFromPrimitiveSegment<T>;
 }
 
 void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType &type) {
@@ -597,7 +508,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateListSegment;
 		functions.write_data = WriteDataToVarcharSegment;
 		functions.read_data = ReadDataFromVarcharSegment;
-		functions.copy_data = CopyDataFromListSegment;
 
 		functions.child_functions.emplace_back();
 		SegmentPrimitiveFunction<char>(functions.child_functions.back());
@@ -607,7 +517,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateListSegment;
 		functions.write_data = WriteDataToListSegment;
 		functions.read_data = ReadDataFromListSegment;
-		functions.copy_data = CopyDataFromListSegment;
 
 		// recurse
 		functions.child_functions.emplace_back();
@@ -618,7 +527,6 @@ void GetSegmentDataFunctions(ListSegmentFunctions &functions, const LogicalType
 		functions.create_segment = CreateStructSegment;
 		functions.write_data = WriteDataToStructSegment;
 		functions.read_data = ReadDataFromStructSegment;
-		functions.copy_data = CopyDataFromStructSegment;
 
 		// recurse
 		auto child_types = StructType::GetChildTypes(type);

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

@@ -892,6 +892,27 @@ void Vector::ToUnifiedFormat(idx_t count, UnifiedVectorFormat &format) {
 	}
 }
 
+void Vector::RecursiveToUnifiedFormat(Vector &input, idx_t count, RecursiveUnifiedVectorFormat &data) {
+
+	input.ToUnifiedFormat(count, data.unified);
+
+	if (input.GetType().InternalType() == PhysicalType::LIST) {
+		auto &child = ListVector::GetEntry(input);
+		auto child_count = ListVector::GetListSize(input);
+		data.children.emplace_back();
+		Vector::RecursiveToUnifiedFormat(child, child_count, data.children.back());
+
+	} else if (input.GetType().InternalType() == PhysicalType::STRUCT) {
+		auto &children = StructVector::GetEntries(input);
+		for (idx_t i = 0; i < children.size(); i++) {
+			data.children.emplace_back();
+		}
+		for (idx_t i = 0; i < children.size(); i++) {
+			Vector::RecursiveToUnifiedFormat(*children[i], count, data.children[i]);
+		}
+	}
+}
+
 void Vector::Sequence(int64_t start, int64_t increment, idx_t count) {
 	this->vector_type = VectorType::SEQUENCE_VECTOR;
 	this->buffer = make_buffer<VectorBuffer>(sizeof(int64_t) * 3);

package/src/duckdb/src/core_functions/aggregate/holistic/mode.cpp

@@ -31,8 +31,6 @@ struct hash<duckdb::hugeint_t> {
 
 namespace duckdb {
 
-using FrameBounds = std::pair<idx_t, idx_t>;
-
 template <class KEY_TYPE>
 struct ModeState {
 	struct ModeAttr {
@@ -225,31 +223,31 @@ struct ModeFunction {
 		if (state.nonzero <= tau * state.frequency_map->size()) {
 			state.Reset();
 			// for f ∈ F do
-			for (auto f = frame.first; f < frame.second; ++f) {
+			for (auto f = frame.start; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
 		} else {
 			// for f ∈ P \ F do
-			for (auto p = prev.first; p < frame.first; ++p) {
+			for (auto p = prev.start; p < frame.start; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
-			for (auto p = frame.second; p < prev.second; ++p) {
+			for (auto p = frame.end; p < prev.end; ++p) {
 				if (included(p)) {
 					state.ModeRm(KEY_TYPE(data[p]), p);
 				}
 			}
 
 			// for f ∈ F \ P do
-			for (auto f = frame.first; f < prev.first; ++f) {
+			for (auto f = frame.start; f < prev.start; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}
 			}
-			for (auto f = prev.second; f < frame.second; ++f) {
+			for (auto f = prev.end; f < frame.end; ++f) {
 				if (included(f)) {
 					state.ModeAdd(KEY_TYPE(data[f]), f);
 				}