duckdb 0.7.2-dev2867.0 → 0.7.2-dev3117.0

package/src/duckdb/src/common/enums/expression_type.cpp

@@ -1,16 +1,228 @@
 #include "duckdb/common/enums/expression_type.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
 string ExpressionTypeToString(ExpressionType type) {
-	return EnumSerializer::EnumToString(type);
+	switch (type) {
+	case ExpressionType::OPERATOR_CAST:
+		return "CAST";
+	case ExpressionType::OPERATOR_NOT:
+		return "NOT";
+	case ExpressionType::OPERATOR_IS_NULL:
+		return "IS_NULL";
+	case ExpressionType::OPERATOR_IS_NOT_NULL:
+		return "IS_NOT_NULL";
+	case ExpressionType::COMPARE_EQUAL:
+		return "EQUAL";
+	case ExpressionType::COMPARE_NOTEQUAL:
+		return "NOTEQUAL";
+	case ExpressionType::COMPARE_LESSTHAN:
+		return "LESSTHAN";
+	case ExpressionType::COMPARE_GREATERTHAN:
+		return "GREATERTHAN";
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		return "LESSTHANOREQUALTO";
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		return "GREATERTHANOREQUALTO";
+	case ExpressionType::COMPARE_IN:
+		return "IN";
+	case ExpressionType::COMPARE_DISTINCT_FROM:
+		return "DISTINCT_FROM";
+	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		return "NOT_DISTINCT_FROM";
+	case ExpressionType::CONJUNCTION_AND:
+		return "AND";
+	case ExpressionType::CONJUNCTION_OR:
+		return "OR";
+	case ExpressionType::VALUE_CONSTANT:
+		return "CONSTANT";
+	case ExpressionType::VALUE_PARAMETER:
+		return "PARAMETER";
+	case ExpressionType::VALUE_TUPLE:
+		return "TUPLE";
+	case ExpressionType::VALUE_TUPLE_ADDRESS:
+		return "TUPLE_ADDRESS";
+	case ExpressionType::VALUE_NULL:
+		return "NULL";
+	case ExpressionType::VALUE_VECTOR:
+		return "VECTOR";
+	case ExpressionType::VALUE_SCALAR:
+		return "SCALAR";
+	case ExpressionType::AGGREGATE:
+		return "AGGREGATE";
+	case ExpressionType::WINDOW_AGGREGATE:
+		return "WINDOW_AGGREGATE";
+	case ExpressionType::WINDOW_RANK:
+		return "RANK";
+	case ExpressionType::WINDOW_RANK_DENSE:
+		return "RANK_DENSE";
+	case ExpressionType::WINDOW_PERCENT_RANK:
+		return "PERCENT_RANK";
+	case ExpressionType::WINDOW_ROW_NUMBER:
+		return "ROW_NUMBER";
+	case ExpressionType::WINDOW_FIRST_VALUE:
+		return "FIRST_VALUE";
+	case ExpressionType::WINDOW_LAST_VALUE:
+		return "LAST_VALUE";
+	case ExpressionType::WINDOW_NTH_VALUE:
+		return "NTH_VALUE";
+	case ExpressionType::WINDOW_CUME_DIST:
+		return "CUME_DIST";
+	case ExpressionType::WINDOW_LEAD:
+		return "LEAD";
+	case ExpressionType::WINDOW_LAG:
+		return "LAG";
+	case ExpressionType::WINDOW_NTILE:
+		return "NTILE";
+	case ExpressionType::FUNCTION:
+		return "FUNCTION";
+	case ExpressionType::CASE_EXPR:
+		return "CASE";
+	case ExpressionType::OPERATOR_NULLIF:
+		return "NULLIF";
+	case ExpressionType::OPERATOR_COALESCE:
+		return "COALESCE";
+	case ExpressionType::ARRAY_EXTRACT:
+		return "ARRAY_EXTRACT";
+	case ExpressionType::ARRAY_SLICE:
+		return "ARRAY_SLICE";
+	case ExpressionType::STRUCT_EXTRACT:
+		return "STRUCT_EXTRACT";
+	case ExpressionType::SUBQUERY:
+		return "SUBQUERY";
+	case ExpressionType::STAR:
+		return "STAR";
+	case ExpressionType::PLACEHOLDER:
+		return "PLACEHOLDER";
+	case ExpressionType::COLUMN_REF:
+		return "COLUMN_REF";
+	case ExpressionType::FUNCTION_REF:
+		return "FUNCTION_REF";
+	case ExpressionType::TABLE_REF:
+		return "TABLE_REF";
+	case ExpressionType::CAST:
+		return "CAST";
+	case ExpressionType::COMPARE_NOT_IN:
+		return "COMPARE_NOT_IN";
+	case ExpressionType::COMPARE_BETWEEN:
+		return "COMPARE_BETWEEN";
+	case ExpressionType::COMPARE_NOT_BETWEEN:
+		return "COMPARE_NOT_BETWEEN";
+	case ExpressionType::VALUE_DEFAULT:
+		return "VALUE_DEFAULT";
+	case ExpressionType::BOUND_REF:
+		return "BOUND_REF";
+	case ExpressionType::BOUND_COLUMN_REF:
+		return "BOUND_COLUMN_REF";
+	case ExpressionType::BOUND_FUNCTION:
+		return "BOUND_FUNCTION";
+	case ExpressionType::BOUND_AGGREGATE:
+		return "BOUND_AGGREGATE";
+	case ExpressionType::GROUPING_FUNCTION:
+		return "GROUPING";
+	case ExpressionType::ARRAY_CONSTRUCTOR:
+		return "ARRAY_CONSTRUCTOR";
+	case ExpressionType::TABLE_STAR:
+		return "TABLE_STAR";
+	case ExpressionType::BOUND_UNNEST:
+		return "BOUND_UNNEST";
+	case ExpressionType::COLLATE:
+		return "COLLATE";
+	case ExpressionType::POSITIONAL_REFERENCE:
+		return "POSITIONAL_REFERENCE";
+	case ExpressionType::BOUND_LAMBDA_REF:
+		return "BOUND_LAMBDA_REF";
+	case ExpressionType::LAMBDA:
+		return "LAMBDA";
+	case ExpressionType::ARROW:
+		return "ARROW";
+	case ExpressionType::INVALID:
+		break;
+	}
+	return "INVALID";
 }
-
 string ExpressionClassToString(ExpressionClass type) {
-	return EnumSerializer::EnumToString(type);
+	switch (type) {
+	case ExpressionClass::INVALID:
+		return "INVALID";
+	case ExpressionClass::AGGREGATE:
+		return "AGGREGATE";
+	case ExpressionClass::CASE:
+		return "CASE";
+	case ExpressionClass::CAST:
+		return "CAST";
+	case ExpressionClass::COLUMN_REF:
+		return "COLUMN_REF";
+	case ExpressionClass::COMPARISON:
+		return "COMPARISON";
+	case ExpressionClass::CONJUNCTION:
+		return "CONJUNCTION";
+	case ExpressionClass::CONSTANT:
+		return "CONSTANT";
+	case ExpressionClass::DEFAULT:
+		return "DEFAULT";
+	case ExpressionClass::FUNCTION:
+		return "FUNCTION";
+	case ExpressionClass::OPERATOR:
+		return "OPERATOR";
+	case ExpressionClass::STAR:
+		return "STAR";
+	case ExpressionClass::SUBQUERY:
+		return "SUBQUERY";
+	case ExpressionClass::WINDOW:
+		return "WINDOW";
+	case ExpressionClass::PARAMETER:
+		return "PARAMETER";
+	case ExpressionClass::COLLATE:
+		return "COLLATE";
+	case ExpressionClass::LAMBDA:
+		return "LAMBDA";
+	case ExpressionClass::POSITIONAL_REFERENCE:
+		return "POSITIONAL_REFERENCE";
+	case ExpressionClass::BETWEEN:
+		return "BETWEEN";
+	case ExpressionClass::BOUND_AGGREGATE:
+		return "BOUND_AGGREGATE";
+	case ExpressionClass::BOUND_CASE:
+		return "BOUND_CASE";
+	case ExpressionClass::BOUND_CAST:
+		return "BOUND_CAST";
+	case ExpressionClass::BOUND_COLUMN_REF:
+		return "BOUND_COLUMN_REF";
+	case ExpressionClass::BOUND_COMPARISON:
+		return "BOUND_COMPARISON";
+	case ExpressionClass::BOUND_CONJUNCTION:
+		return "BOUND_CONJUNCTION";
+	case ExpressionClass::BOUND_CONSTANT:
+		return "BOUND_CONSTANT";
+	case ExpressionClass::BOUND_DEFAULT:
+		return "BOUND_DEFAULT";
+	case ExpressionClass::BOUND_FUNCTION:
+		return "BOUND_FUNCTION";
+	case ExpressionClass::BOUND_OPERATOR:
+		return "BOUND_OPERATOR";
+	case ExpressionClass::BOUND_PARAMETER:
+		return "BOUND_PARAMETER";
+	case ExpressionClass::BOUND_REF:
+		return "BOUND_REF";
+	case ExpressionClass::BOUND_SUBQUERY:
+		return "BOUND_SUBQUERY";
+	case ExpressionClass::BOUND_WINDOW:
+		return "BOUND_WINDOW";
+	case ExpressionClass::BOUND_BETWEEN:
+		return "BOUND_BETWEEN";
+	case ExpressionClass::BOUND_UNNEST:
+		return "BOUND_UNNEST";
+	case ExpressionClass::BOUND_LAMBDA:
+		return "BOUND_LAMBDA";
+	case ExpressionClass::BOUND_EXPRESSION:
+		return "BOUND_EXPRESSION";
+	default:
+		return "ExpressionClass::!!UNIMPLEMENTED_CASE!!";
+	}
 }
 
 string ExpressionTypeToOperator(ExpressionType type) {

package/src/duckdb/src/common/enums/join_type.cpp

@@ -1,12 +1,8 @@
 #include "duckdb/common/enums/join_type.hpp"
-#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
-string JoinTypeToString(JoinType type) {
-	return EnumSerializer::EnumToString(type);
-}
-
 bool IsLeftOuterJoin(JoinType type) {
 	return type == JoinType::LEFT || type == JoinType::OUTER;
 }
@@ -15,4 +11,9 @@ bool IsRightOuterJoin(JoinType type) {
 	return type == JoinType::OUTER || type == JoinType::RIGHT;
 }
 
+// **DEPRECATED**: Use EnumUtil directly instead.
+string JoinTypeToString(JoinType type) {
+	return EnumUtil::ToString(type);
+}
+
 } // namespace duckdb

package/src/duckdb/src/common/enums/physical_operator_type.cpp

@@ -47,6 +47,8 @@ string PhysicalOperatorToString(PhysicalOperatorType type) {
 		return "PROJECTION";
 	case PhysicalOperatorType::COPY_TO_FILE:
 		return "COPY_TO_FILE";
+	case PhysicalOperatorType::BATCH_COPY_TO_FILE:
+		return "BATCH_COPY_TO_FILE";
 	case PhysicalOperatorType::DELIM_JOIN:
 		return "DELIM_JOIN";
 	case PhysicalOperatorType::BLOCKWISE_NL_JOIN:

package/src/duckdb/src/common/exception.cpp

@@ -58,7 +58,7 @@ string Exception::GetStackTrace(int max_depth) {
 #endif
 }
 
-string Exception::ConstructMessageRecursive(const string &msg, vector<ExceptionFormatValue> &values) {
+string Exception::ConstructMessageRecursive(const string &msg, std::vector<ExceptionFormatValue> &values) {
 	return ExceptionFormatValue::Format(msg, values);
 }
 

package/src/duckdb/src/common/exception_format_value.cpp

@@ -53,8 +53,8 @@ ExceptionFormatValue ExceptionFormatValue::CreateFormatValue(hugeint_t value) {
 	return ExceptionFormatValue(value);
 }
 
-string ExceptionFormatValue::Format(const string &msg, vector<ExceptionFormatValue> &values) {
-	vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
+string ExceptionFormatValue::Format(const string &msg, std::vector<ExceptionFormatValue> &values) {
+	std::vector<duckdb_fmt::basic_format_arg<duckdb_fmt::printf_context>> format_args;
 	for (auto &val : values) {
 		switch (val.type) {
 		case ExceptionFormatValueType::FORMAT_VALUE_TYPE_DOUBLE:

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -52,6 +52,7 @@ bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFile
 		options.filename = BooleanValue::Get(val);
 	} else if (loption == "hive_partitioning") {
 		options.hive_partitioning = BooleanValue::Get(val);
+		options.auto_detect_hive_partitioning = false;
 	} else if (loption == "union_by_name") {
 		options.union_by_name = BooleanValue::Get(val);
 	} else {
@@ -107,12 +108,25 @@ MultiFileReaderBindData MultiFileReader::BindOptions(MultiFileReaderOptions &opt
 			auto file_partitions = HivePartitioning::Parse(f);
 			for (auto &part_info : partitions) {
 				if (file_partitions.find(part_info.first) == file_partitions.end()) {
+					if (options.auto_detect_hive_partitioning == true) {
+						throw BinderException(
+						    "Hive partitioning was enabled automatically, but an error was encountered: Hive partition "
+						    "mismatch between file \"%s\" and \"%s\": key \"%s\" not found\n\nTo switch off hive "
+						    "partition, set: HIVE_PARTITIONING=0",
+						    files[0], f, part_info.first);
+					}
 					throw BinderException(
 					    "Hive partition mismatch between file \"%s\" and \"%s\": key \"%s\" not found", files[0], f,
 					    part_info.first);
 				}
 			}
 			if (partitions.size() != file_partitions.size()) {
+				if (options.auto_detect_hive_partitioning == true) {
+					throw BinderException("Hive partitioning was enabled automatically, but an error was encountered: "
+					                      "Hive partition mismatch between file \"%s\" and \"%s\"\n\nTo switch off "
+					                      "hive partition, set: HIVE_PARTITIONING=0",
+					                      files[0], f);
+				}
 				throw BinderException("Hive partition mismatch between file \"%s\" and \"%s\"", files[0], f);
 			}
 		}

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -0,0 +1,143 @@
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+
+namespace duckdb {
+
+void BinaryDeserializer::SetTag(const char *tag) {
+	current_tag = tag;
+	stack.back().read_field_count++;
+}
+
+//===--------------------------------------------------------------------===//
+// Nested Types Hooks
+//===--------------------------------------------------------------------===//
+void BinaryDeserializer::OnObjectBegin() {
+	auto expected_field_count = ReadPrimitive<uint32_t>();
+	auto expected_size = ReadPrimitive<uint64_t>();
+	D_ASSERT(expected_field_count > 0);
+	D_ASSERT(expected_size > 0);
+
+	stack.emplace_back(expected_field_count, expected_size);
+}
+
+void BinaryDeserializer::OnObjectEnd() {
+	auto &frame = stack.back();
+	if (frame.read_field_count < frame.expected_field_count) {
+		throw SerializationException("Not all fields were read. This file might have been written with a newer version "
+		                             "of DuckDB and is incompatible with this version of DuckDB.");
+	}
+	stack.pop_back();
+}
+
+idx_t BinaryDeserializer::OnListBegin() {
+	return ReadPrimitive<idx_t>();
+}
+
+void BinaryDeserializer::OnListEnd() {
+}
+
+// Deserialize maps as [ { key: ..., value: ... } ]
+idx_t BinaryDeserializer::OnMapBegin() {
+	return ReadPrimitive<idx_t>();
+}
+
+void BinaryDeserializer::OnMapEntryBegin() {
+}
+
+void BinaryDeserializer::OnMapKeyBegin() {
+}
+
+void BinaryDeserializer::OnMapValueBegin() {
+}
+
+void BinaryDeserializer::OnMapEntryEnd() {
+}
+
+void BinaryDeserializer::OnMapEnd() {
+}
+
+void BinaryDeserializer::OnPairBegin() {
+}
+
+void BinaryDeserializer::OnPairKeyBegin() {
+}
+
+void BinaryDeserializer::OnPairValueBegin() {
+}
+
+void BinaryDeserializer::OnPairEnd() {
+}
+
+bool BinaryDeserializer::OnOptionalBegin() {
+	return ReadPrimitive<bool>();
+}
+
+//===--------------------------------------------------------------------===//
+// Primitive Types
+//===--------------------------------------------------------------------===//
+bool BinaryDeserializer::ReadBool() {
+	return ReadPrimitive<bool>();
+}
+
+int8_t BinaryDeserializer::ReadSignedInt8() {
+	return ReadPrimitive<int8_t>();
+}
+
+uint8_t BinaryDeserializer::ReadUnsignedInt8() {
+	return ReadPrimitive<uint8_t>();
+}
+
+int16_t BinaryDeserializer::ReadSignedInt16() {
+	return ReadPrimitive<int16_t>();
+}
+
+uint16_t BinaryDeserializer::ReadUnsignedInt16() {
+	return ReadPrimitive<uint16_t>();
+}
+
+int32_t BinaryDeserializer::ReadSignedInt32() {
+	return ReadPrimitive<int32_t>();
+}
+
+uint32_t BinaryDeserializer::ReadUnsignedInt32() {
+	return ReadPrimitive<uint32_t>();
+}
+
+int64_t BinaryDeserializer::ReadSignedInt64() {
+	return ReadPrimitive<int64_t>();
+}
+
+uint64_t BinaryDeserializer::ReadUnsignedInt64() {
+	return ReadPrimitive<uint64_t>();
+}
+
+float BinaryDeserializer::ReadFloat() {
+	return ReadPrimitive<float>();
+}
+
+double BinaryDeserializer::ReadDouble() {
+	return ReadPrimitive<double>();
+}
+
+string BinaryDeserializer::ReadString() {
+	uint32_t size = ReadPrimitive<uint32_t>();
+	if (size == 0) {
+		return string();
+	}
+	auto buffer = unique_ptr<data_t[]>(new data_t[size]);
+	ReadData(buffer.get(), size);
+	return string((char *)buffer.get(), size);
+}
+
+interval_t BinaryDeserializer::ReadInterval() {
+	return ReadPrimitive<interval_t>();
+}
+
+hugeint_t BinaryDeserializer::ReadHugeInt() {
+	return ReadPrimitive<hugeint_t>();
+}
+
+void BinaryDeserializer::ReadDataPtr(data_ptr_t &ptr, idx_t count) {
+	ReadData(ptr, count);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -0,0 +1,160 @@
+#include "duckdb/common/serializer/binary_serializer.hpp"
+
+namespace duckdb {
+
+void BinarySerializer::SetTag(const char *tag) {
+	current_tag = tag;
+
+	// Increment the number of fields
+	stack.back().field_count++;
+}
+
+//===--------------------------------------------------------------------===//
+// Nested types
+//===--------------------------------------------------------------------===//
+void BinarySerializer::OnOptionalBegin(bool present) {
+	Write(present);
+}
+
+void BinarySerializer::OnListBegin(idx_t count) {
+	Write(count);
+}
+
+void BinarySerializer::OnListEnd(idx_t count) {
+}
+
+// Serialize maps as arrays of objects with "key" and "value" properties.
+void BinarySerializer::OnMapBegin(idx_t count) {
+	Write(count);
+}
+
+void BinarySerializer::OnMapEntryBegin() {
+}
+
+void BinarySerializer::OnMapKeyBegin() {
+}
+
+void BinarySerializer::OnMapValueBegin() {
+}
+
+void BinarySerializer::OnMapEntryEnd() {
+}
+
+void BinarySerializer::OnMapEnd(idx_t count) {
+}
+
+void BinarySerializer::OnObjectBegin() {
+	stack.push_back(State({0, 0, data.size()}));
+	Write<uint32_t>(0); // Placeholder for the field count
+	Write<uint64_t>(0); // Placeholder for the size
+}
+
+void BinarySerializer::OnObjectEnd() {
+	auto &frame = stack.back();
+	// Patch the field count and size
+	auto message_start = &data[frame.offset];
+	Store<uint32_t>(frame.field_count, message_start);
+	Store<uint64_t>(frame.size, message_start + sizeof(uint32_t));
+	stack.pop_back();
+}
+
+void BinarySerializer::OnPairBegin() {
+}
+
+void BinarySerializer::OnPairKeyBegin() {
+}
+
+void BinarySerializer::OnPairValueBegin() {
+}
+
+void BinarySerializer::OnPairEnd() {
+}
+
+//===--------------------------------------------------------------------===//
+// Primitive types
+//===--------------------------------------------------------------------===//
+void BinarySerializer::WriteNull() {
+	// This should never be called, optional writes should be handled by OnOptionalBegin
+}
+
+void BinarySerializer::WriteValue(uint8_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int8_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint16_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int16_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint32_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int32_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(uint64_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(int64_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(hugeint_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(float value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(double value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(interval_t value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteValue(const string &value) {
+	auto len = value.length();
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value.c_str(), len);
+	}
+}
+
+void BinarySerializer::WriteValue(const string_t value) {
+	auto len = value.GetSize();
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value.GetDataUnsafe(), len);
+	}
+}
+
+void BinarySerializer::WriteValue(const char *value) {
+	auto len = strlen(value);
+	Write<uint32_t>((uint32_t)len);
+	if (len > 0) {
+		WriteData((const_data_ptr_t)value, len);
+	}
+}
+
+void BinarySerializer::WriteValue(bool value) {
+	Write(value);
+}
+
+void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
+	WriteData(ptr, count);
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -554,7 +554,7 @@ void PartitionMergeEvent::Schedule() {
 	auto &ts = TaskScheduler::GetScheduler(context);
 	idx_t num_threads = ts.NumberOfThreads();
 
-	vector<unique_ptr<Task>> merge_tasks;
+	vector<shared_ptr<Task>> merge_tasks;
 	for (idx_t tnum = 0; tnum < num_threads; tnum++) {
 		merge_tasks.emplace_back(make_uniq<PartitionMergeTask>(shared_from_this(), context, merge_states));
 	}

package/src/duckdb/src/common/string_util.cpp

@@ -163,6 +163,11 @@ string StringUtil::BytesToHumanReadableString(idx_t bytes) {
 	megabytes -= gigabytes * 1000;
 	auto terabytes = gigabytes / 1000;
 	gigabytes -= terabytes * 1000;
+	auto petabytes = terabytes / 1000;
+	terabytes -= petabytes * 1000;
+	if (petabytes > 0) {
+		return to_string(petabytes) + "." + to_string(terabytes / 100) + "PB";
+	}
 	if (terabytes > 0) {
 		return to_string(terabytes) + "." + to_string(gigabytes / 100) + "TB";
 	} else if (gigabytes > 0) {
@@ -172,7 +177,7 @@ string StringUtil::BytesToHumanReadableString(idx_t bytes) {
 	} else if (kilobytes > 0) {
 		return to_string(kilobytes) + "KB";
 	} else {
-		return to_string(bytes) + " bytes";
+		return to_string(bytes) + (bytes == 1 ? " byte" : " bytes");
 	}
 }
 

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/fast_mem.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/row/tuple_data_collection.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -135,7 +136,7 @@ void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &s
 		break;
 	}
 	default:
-		throw NotImplementedException("ComputeHeapSizes for %s", LogicalTypeIdToString(source_v.GetType().id()));
+		throw NotImplementedException("ComputeHeapSizes for %s", EnumUtil::ToString(source_v.GetType().id()));
 	}
 }
 
@@ -164,8 +165,7 @@ void TupleDataCollection::WithinListHeapComputeSizes(Vector &heap_sizes_v, const
 		                                                    append_count, list_data);
 		break;
 	default:
-		throw NotImplementedException("WithinListHeapComputeSizes for %s",
-		                              LogicalTypeIdToString(source_v.GetType().id()));
+		throw NotImplementedException("WithinListHeapComputeSizes for %s", EnumUtil::ToString(source_v.GetType().id()));
 	}
 }