duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

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

@@ -163,17 +163,26 @@ int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 	if (!valid) {
 		return 0;
 	}
-	// Construct the string_t
 	uint32_t left_string_size = Load<uint32_t>(left_ptr);
 	uint32_t right_string_size = Load<uint32_t>(right_ptr);
 	left_ptr += sizeof(uint32_t);
 	right_ptr += sizeof(uint32_t);
-	string_t left_val((const char *)left_ptr, left_string_size);
-	string_t right_val((const char *)right_ptr, right_string_size);
+	auto memcmp_res = memcmp((const char *)left_ptr, (const char *)right_ptr,
+	                         std::min<uint32_t>(left_string_size, right_string_size));
+
 	left_ptr += left_string_size;
 	right_ptr += right_string_size;
-	// Compare
-	return TemplatedCompareVal<string_t>((data_ptr_t)&left_val, (data_ptr_t)&right_val);
+
+	if (memcmp_res != 0) {
+		return memcmp_res;
+	}
+	if (left_string_size == right_string_size) {
+		return 0;
+	}
+	if (left_string_size < right_string_size) {
+		return -1;
+	}
+	return 1;
 }
 
 int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,

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

@@ -3,7 +3,6 @@
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
 
 #include <algorithm>
 #include <numeric>
@@ -66,9 +65,8 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			prefix_lengths.back() = GetNestedSortingColSize(col_size, expr.return_type);
 		} else if (physical_type == PhysicalType::VARCHAR) {
 			idx_t size_before = col_size;
-			if (stats.back()) {
-				auto &str_stats = (StringStatistics &)*stats.back();
-				col_size += str_stats.max_string_length;
+			if (stats.back() && StringStats::HasMaxStringLength(*stats.back())) {
+				col_size += StringStats::MaxStringLength(*stats.back());
 				if (col_size > 12) {
 					col_size = 12;
 				} else {
@@ -95,9 +93,9 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			if (bytes_to_fill == 0) {
 				break;
 			}
-			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx]) {
-				auto &str_stats = (StringStatistics &)*stats[col_idx];
-				idx_t diff = str_stats.max_string_length - prefix_lengths[col_idx];
+			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx] &&
+			    StringStats::HasMaxStringLength(*stats[col_idx])) {
+				idx_t diff = StringStats::MaxStringLength(*stats[col_idx]) - prefix_lengths[col_idx];
 				if (diff > 0) {
 					// Increase all sizes accordingly
 					idx_t increase = MinValue(bytes_to_fill, diff);

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

@@ -70,7 +70,6 @@ void SortedData::Unswizzle() {
 		auto data_handle_p = buffer_manager.Pin(data_block->block);
 		auto heap_handle_p = buffer_manager.Pin(heap_block->block);
 		RowOperations::UnswizzlePointers(layout, data_handle_p.Ptr(), heap_handle_p.Ptr(), data_block->count);
-		data_block->block->SetSwizzling("SortedData::Unswizzle");
 		state.heap_blocks.push_back(std::move(heap_block));
 		state.pinned_blocks.push_back(std::move(heap_handle_p));
 	}

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

@@ -11,9 +11,23 @@
 #include <sstream>
 #include <stdarg.h>
 #include <string.h>
+#include <random>
 
 namespace duckdb {
 
+string StringUtil::GenerateRandomName(idx_t length) {
+	std::random_device rd;
+	std::mt19937 gen(rd());
+	std::uniform_int_distribution<> dis(0, 15);
+
+	std::stringstream ss;
+	ss << std::hex;
+	for (idx_t i = 0; i < length; i++) {
+		ss << dis(gen);
+	}
+	return ss.str();
+}
+
 bool StringUtil::Contains(const string &haystack, const string &needle) {
 	return (haystack.find(needle) != string::npos);
 }
@@ -191,11 +205,14 @@ vector<string> StringUtil::Split(const string &input, const string &split) {
 
 		// Push the substring [last, next) on to splits
 		string substr = input.substr(last, next - last);
-		if (substr.empty() == false) {
+		if (!substr.empty()) {
 			splits.push_back(substr);
 		}
 		last = next + split_len;
 	}
+	if (splits.empty()) {
+		splits.push_back(input);
+	}
 	return splits;
 }
 

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

@@ -4,71 +4,67 @@
 
 namespace duckdb {
 
-void Bit::SetEmptyBitString(string_t &target, string_t &input) {
-	char *res_buf = target.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
-	memset(res_buf, 0, input.GetSize());
-	res_buf[0] = buf[0];
+// **** helper functions ****
+static char ComputePadding(idx_t len) {
+	return (8 - (len % 8)) % 8;
 }
 
-idx_t Bit::BitLength(string_t bits) {
-	return ((bits.GetSize() - 1) * 8) - GetPadding(bits);
+idx_t Bit::ComputeBitstringLen(idx_t len) {
+	idx_t result = len / 8;
+	if (len % 8 != 0) {
+		result++;
+	}
+	// additional first byte to store info on zero padding
+	result++;
+	return result;
 }
 
-idx_t Bit::OctetLength(string_t bits) {
-	return bits.GetSize() - 1;
+static inline idx_t GetBitPadding(const string_t &bit_string) {
+	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
+	D_ASSERT(idx_t(data[0]) <= 8);
+	return data[0];
 }
 
-idx_t Bit::BitCount(string_t bits) {
-	idx_t count = 0;
-	const char *buf = bits.GetDataUnsafe();
-	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
-		}
+static inline idx_t GetBitSize(const string_t &str) {
+	string error_message;
+	idx_t str_len;
+	if (!Bit::TryGetBitStringSize(str, str_len, &error_message)) {
+		throw ConversionException(error_message);
 	}
-	return count;
+	return str_len;
 }
 
-idx_t Bit::BitPosition(string_t substring, string_t bits) {
-	const char *buf = bits.GetDataUnsafe();
-	auto len = bits.GetSize();
-	auto substr_len = BitLength(substring);
-	idx_t substr_idx = 0;
-
-	for (idx_t bit_idx = GetPadding(bits); bit_idx < 8; bit_idx++) {
-		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
-		if (bit == GetBit(substring, substr_idx)) {
-			substr_idx++;
-			if (substr_idx == substr_len) {
-				return (bit_idx - GetPadding(bits)) - substr_len + 2;
-			}
-		} else {
-			substr_idx = 0;
-		}
+void Bit::Finalize(string_t &str) {
+	// bit strings require all padding bits to be set to 1
+	// this method sets all padding bits to 1
+	auto padding = GetBitPadding(str);
+	for (idx_t i = 0; i < idx_t(padding); i++) {
+		Bit::SetBitInternal(str, i, 1);
 	}
+	Bit::Verify(str);
+}
 
-	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
-		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
-			if (bit == GetBit(substring, substr_idx)) {
-				substr_idx++;
-				if (substr_idx == substr_len) {
-					return (((byte_idx - 1) * 8) + bit_idx - GetPadding(bits)) - substr_len + 2;
-				}
-			} else {
-				substr_idx = 0;
-			}
-		}
-	}
-	return 0;
+void Bit::SetEmptyBitString(string_t &target, string_t &input) {
+	char *res_buf = target.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
+	memset(res_buf, 0, input.GetSize());
+	res_buf[0] = buf[0];
+	Bit::Finalize(target);
 }
 
+void Bit::SetEmptyBitString(string_t &target, idx_t len) {
+	char *res_buf = target.GetDataWriteable();
+	memset(res_buf, 0, target.GetSize());
+	res_buf[0] = ComputePadding(len);
+	Bit::Finalize(target);
+}
+
+// **** casting functions ****
 void Bit::ToString(string_t bits, char *output) {
 	auto data = (const_data_ptr_t)bits.GetDataUnsafe();
 	auto len = bits.GetSize();
 
-	idx_t padding = GetPadding(bits);
+	idx_t padding = GetBitPadding(bits);
 	idx_t output_idx = 0;
 	for (idx_t bit_idx = padding; bit_idx < 8; bit_idx++) {
 		output[output_idx++] = data[1] & (1 << (7 - bit_idx)) ? '1' : '0';
@@ -101,23 +97,19 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 			return false;
 		}
 	}
-	str_len = str_len % 8 ? (str_len / 8) + 1 : str_len / 8;
-	str_len++; // additional first byte to store info on zero padding
-	return true;
-}
-
-idx_t Bit::GetBitSize(string_t str) {
-	string error_message;
-	idx_t str_len;
-	if (!Bit::TryGetBitStringSize(str, str_len, &error_message)) {
-		throw ConversionException(error_message);
+	if (str_len == 0) {
+		string error = "Cannot cast empty string to BIT";
+		HandleCastError::AssignError(error, error_message);
+		return false;
 	}
-	return str_len;
+	str_len = ComputeBitstringLen(str_len);
+	return true;
 }
 
-void Bit::ToBit(string_t str, data_ptr_t output) {
+void Bit::ToBit(string_t str, string_t &output_str) {
 	auto data = (const_data_ptr_t)str.GetDataUnsafe();
 	auto len = str.GetSize();
+	auto output = output_str.GetDataWriteable();
 
 	char byte = 0;
 	idx_t padded_byte = len % 8;
@@ -142,57 +134,124 @@ void Bit::ToBit(string_t str, data_ptr_t output) {
 		}
 		*(output++) = byte;
 	}
+	Bit::Finalize(output_str);
+	Bit::Verify(output_str);
 }
 
 string Bit::ToBit(string_t str) {
 	auto bit_len = GetBitSize(str);
 	auto buffer = std::unique_ptr<char[]>(new char[bit_len]);
-	Bit::ToBit(str, (data_ptr_t)buffer.get());
-	return string(buffer.get(), bit_len);
+	string_t output_str(buffer.get(), bit_len);
+	Bit::ToBit(str, output_str);
+	return output_str.GetString();
 }
 
-idx_t Bit::GetBit(string_t bit_string, idx_t n) {
-	const char *buf = bit_string.GetDataUnsafe();
-	n += GetPadding(bit_string);
+// **** scalar functions ****
+void Bit::BitString(const string_t &input, const idx_t &bit_length, string_t &result) {
+	char *res_buf = result.GetDataWriteable();
+	const char *buf = input.GetDataUnsafe();
 
-	char byte = buf[(n / 8) + 1] >> (7 - (n % 8));
-	return (byte & 1 ? 1 : 0);
+	auto padding = ComputePadding(bit_length);
+	res_buf[0] = padding;
+	for (idx_t i = 0; i < bit_length; i++) {
+		if (i < bit_length - input.GetSize()) {
+			Bit::SetBit(result, i, 0);
+		} else {
+			idx_t bit = buf[i - (bit_length - input.GetSize())] == '1' ? 1 : 0;
+			Bit::SetBit(result, i, bit);
+		}
+	}
+	Bit::Finalize(result);
 }
 
-void Bit::SetBit(const string_t &bit_string, idx_t n, idx_t new_value, string_t &result) {
-	char *result_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetDataUnsafe();
-	n += GetPadding(bit_string);
+idx_t Bit::BitLength(string_t bits) {
+	return ((bits.GetSize() - 1) * 8) - GetBitPadding(bits);
+}
 
-	memcpy(result_buf, buf, bit_string.GetSize());
-	char shift_byte = 1 << (7 - (n % 8));
-	if (new_value == 0) {
-		shift_byte = ~shift_byte;
-		result_buf[(n / 8) + 1] = buf[(n / 8) + 1] & shift_byte;
-	} else {
-		result_buf[(n / 8) + 1] = buf[(n / 8) + 1] | shift_byte;
+idx_t Bit::OctetLength(string_t bits) {
+	return bits.GetSize() - 1;
+}
+
+idx_t Bit::BitCount(string_t bits) {
+	idx_t count = 0;
+	const char *buf = bits.GetDataUnsafe();
+	for (idx_t byte_idx = 1; byte_idx < OctetLength(bits) + 1; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			count += (buf[byte_idx] & (1 << bit_idx)) ? 1 : 0;
+		}
 	}
+	return count - GetBitPadding(bits);
+}
+
+idx_t Bit::BitPosition(string_t substring, string_t bits) {
+	const char *buf = bits.GetDataUnsafe();
+	auto len = bits.GetSize();
+	auto substr_len = BitLength(substring);
+	idx_t substr_idx = 0;
+
+	for (idx_t bit_idx = GetBitPadding(bits); bit_idx < 8; bit_idx++) {
+		idx_t bit = buf[1] & (1 << (7 - bit_idx)) ? 1 : 0;
+		if (bit == GetBit(substring, substr_idx)) {
+			substr_idx++;
+			if (substr_idx == substr_len) {
+				return (bit_idx - GetBitPadding(bits)) - substr_len + 2;
+			}
+		} else {
+			substr_idx = 0;
+		}
+	}
+
+	for (idx_t byte_idx = 2; byte_idx < len; byte_idx++) {
+		for (idx_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+			idx_t bit = buf[byte_idx] & (1 << (7 - bit_idx)) ? 1 : 0;
+			if (bit == GetBit(substring, substr_idx)) {
+				substr_idx++;
+				if (substr_idx == substr_len) {
+					return (((byte_idx - 1) * 8) + bit_idx - GetBitPadding(bits)) - substr_len + 2;
+				}
+			} else {
+				substr_idx = 0;
+			}
+		}
+	}
+	return 0;
+}
+
+idx_t Bit::GetBit(string_t bit_string, idx_t n) {
+	return Bit::GetBitInternal(bit_string, n + GetBitPadding(bit_string));
+}
+
+idx_t Bit::GetBitIndex(idx_t n) {
+	return n / 8 + 1;
+}
+
+idx_t Bit::GetBitInternal(string_t bit_string, idx_t n) {
+	const char *buf = bit_string.GetDataUnsafe();
+	auto idx = Bit::GetBitIndex(n);
+	D_ASSERT(idx < bit_string.GetSize());
+	char byte = buf[idx] >> (7 - (n % 8));
+	return (byte & 1 ? 1 : 0);
 }
 
 void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) {
+	SetBitInternal(bit_string, n + GetBitPadding(bit_string), new_value);
+}
+
+void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) {
 	char *buf = bit_string.GetDataWriteable();
-	n += GetPadding(bit_string);
 
+	auto idx = Bit::GetBitIndex(n);
+	D_ASSERT(idx < bit_string.GetSize());
 	char shift_byte = 1 << (7 - (n % 8));
 	if (new_value == 0) {
 		shift_byte = ~shift_byte;
-		buf[(n / 8) + 1] &= shift_byte;
+		buf[idx] &= shift_byte;
 	} else {
-		buf[(n / 8) + 1] |= shift_byte;
+		buf[idx] |= shift_byte;
 	}
 }
 
-inline idx_t Bit::GetPadding(const string_t &bit_string) {
-	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
-	return data[0];
-}
-
-// **** BITWISE OPERATORS ****
+// **** BITWISE operators ****
 void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
 	char *res_buf = result.GetDataWriteable();
 	const char *buf = bit_string.GetDataUnsafe();
@@ -205,6 +264,7 @@ void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &r
 			Bit::SetBit(result, i, bit);
 		}
 	}
+	Bit::Finalize(result);
 }
 
 void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
@@ -219,6 +279,8 @@ void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &re
 			Bit::SetBit(result, i, 0);
 		}
 	}
+	Bit::Finalize(result);
+	Bit::Verify(result);
 }
 
 void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -234,6 +296,8 @@ void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result)
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
 		buf[i] = l_buf[i] & r_buf[i];
 	}
+	// and should preserve padding bits
+	Bit::Verify(result);
 }
 
 void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -249,6 +313,8 @@ void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result)
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
 		buf[i] = l_buf[i] | r_buf[i];
 	}
+	// or should preserve padding bits
+	Bit::Verify(result);
 }
 
 void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result) {
@@ -264,6 +330,7 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
 		buf[i] = l_buf[i] ^ r_buf[i];
 	}
+	Bit::Finalize(result);
 }
 
 void Bit::BitwiseNot(const string_t &input, string_t &result) {
@@ -274,5 +341,17 @@ void Bit::BitwiseNot(const string_t &input, string_t &result) {
 	for (idx_t i = 1; i < input.GetSize(); i++) {
 		result_buf[i] = ~buf[i];
 	}
+	Bit::Finalize(result);
 }
+
+void Bit::Verify(const string_t &input) {
+#ifdef DEBUG
+	// bit strings require all padding bits to be set to 1
+	auto padding = GetBitPadding(input);
+	for (idx_t i = 0; i < padding; i++) {
+		D_ASSERT(Bit::GetBitInternal(input, i));
+	}
+#endif
+}
+
 } // namespace duckdb

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

@@ -20,7 +20,7 @@ const int Blob::HEX_MAP[256] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
 
 bool IsRegularCharacter(data_t c) {
-	return c >= 32 && c <= 127 && c != '\\' && c != '\'' && c != '"';
+	return c >= 32 && c <= 126 && c != '\\' && c != '\'' && c != '"';
 }
 
 idx_t Blob::GetStringSize(string_t blob) {

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

@@ -143,7 +143,7 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 			auto &rhs = other.GetChunk(chunk_idx);
 			lhs->data.reserve(rhs.data.size());
 			for (auto &v : rhs.data) {
-				lhs->data.emplace_back(Vector(v));
+				lhs->data.emplace_back(v);
 			}
 			lhs->SetCardinality(rhs.size());
 			chunks.push_back(std::move(lhs));
@@ -156,7 +156,7 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 			auto &rhs = other.GetChunk(chunk_idx);
 			D_ASSERT(lhs.size() == rhs.size());
 			for (auto &v : rhs.data) {
-				lhs.data.emplace_back(Vector(v));
+				lhs.data.emplace_back(v);
 			}
 		}
 	}

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

@@ -5,6 +5,7 @@
 #include "duckdb/common/types/column_data_collection_segment.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/types/value_map.hpp"
 
 namespace duckdb {
 
@@ -944,6 +945,12 @@ void ColumnDataCollection::Reset() {
 	allocator = make_shared<ColumnDataAllocator>(*allocator);
 }
 
+struct ValueResultEquals {
+	bool operator()(const Value &a, const Value &b) const {
+		return Value::DefaultValuesAreEqual(a, b);
+	}
+};
+
 bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const ColumnDataCollection &right,
                                         string &error_message) {
 	if (left.ColumnCount() != right.ColumnCount()) {
@@ -959,13 +966,43 @@ bool ColumnDataCollection::ResultEquals(const ColumnDataCollection &left, const
 	for (idx_t r = 0; r < left.Count(); r++) {
 		for (idx_t c = 0; c < left.ColumnCount(); c++) {
 			auto lvalue = left_rows.GetValue(c, r);
-			auto rvalue = left_rows.GetValue(c, r);
+			auto rvalue = right_rows.GetValue(c, r);
 			if (!Value::DefaultValuesAreEqual(lvalue, rvalue)) {
 				error_message =
 				    StringUtil::Format("%s <> %s (row: %lld, col: %lld)\n", lvalue.ToString(), rvalue.ToString(), r, c);
-				return false;
+				break;
 			}
 		}
+		if (!error_message.empty()) {
+			break;
+		}
+	}
+	if (!error_message.empty()) {
+		// do an unordered comparison
+		bool found_all = true;
+		for (idx_t c = 0; c < left.ColumnCount(); c++) {
+			std::unordered_multiset<Value, ValueHashFunction, ValueResultEquals> lvalues;
+			for (idx_t r = 0; r < left.Count(); r++) {
+				auto lvalue = left_rows.GetValue(c, r);
+				lvalues.insert(lvalue);
+			}
+			for (idx_t r = 0; r < right.Count(); r++) {
+				auto rvalue = right_rows.GetValue(c, r);
+				auto entry = lvalues.find(rvalue);
+				if (entry == lvalues.end()) {
+					found_all = false;
+					break;
+				}
+				lvalues.erase(entry);
+			}
+			if (!found_all) {
+				break;
+			}
+		}
+		if (!found_all) {
+			return false;
+		}
+		error_message = string();
 	}
 	return true;
 }

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 
 namespace duckdb {
 
@@ -168,11 +169,8 @@ idx_t ColumnDataCollectionSegment::ReadVectorInternal(ChunkManagementState &stat
 		if (type_size > 0) {
 			memcpy(target_data + current_offset * type_size, base_ptr, current_vdata.count * type_size);
 		}
-		// FIXME: use bitwise operations here
 		ValidityMask current_validity(validity_data);
-		for (idx_t k = 0; k < current_vdata.count; k++) {
-			target_validity.Set(current_offset + k, current_validity.RowIsValid(k));
-		}
+		target_validity.SliceInPlace(current_validity, current_offset, 0, current_vdata.count);
 		current_offset += current_vdata.count;
 		next_index = current_vdata.next_data;
 	}
@@ -202,12 +200,16 @@ idx_t ColumnDataCollectionSegment::ReadVector(ChunkManagementState &state, Vecto
 				throw InternalException("Column Data Collection: mismatch in struct child sizes");
 			}
 		}
-	} else if (internal_type == PhysicalType::VARCHAR &&
-	           allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
-		for (auto &swizzle_segment : vdata.swizzle_data) {
-			auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
-			allocator->UnswizzlePointers(state, result, swizzle_segment.offset, swizzle_segment.count,
-			                             string_heap_segment.block_id, string_heap_segment.offset);
+	} else if (internal_type == PhysicalType::VARCHAR) {
+		if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR) {
+			for (auto &swizzle_segment : vdata.swizzle_data) {
+				auto &string_heap_segment = GetVectorData(swizzle_segment.child_index);
+				allocator->UnswizzlePointers(state, result, swizzle_segment.offset, swizzle_segment.count,
+				                             string_heap_segment.block_id, string_heap_segment.offset);
+			}
+		}
+		if (state.properties == ColumnDataScanProperties::DISALLOW_ZERO_COPY) {
+			VectorOperations::Copy(result, result, vdata.count, 0, 0);
 		}
 	}
 	return vcount;

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

@@ -62,7 +62,7 @@ void DataChunk::InitializeEmpty(vector<LogicalType>::const_iterator begin, vecto
 	D_ASSERT(data.empty());                   // can only be initialized once
 	D_ASSERT(std::distance(begin, end) != 0); // empty chunk not allowed
 	for (; begin != end; begin++) {
-		data.emplace_back(Vector(*begin, nullptr));
+		data.emplace_back(*begin, nullptr);
 	}
 }
 

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

@@ -397,47 +397,6 @@ interval_t Interval::FromMicro(int64_t delta_us) {
 	return result;
 }
 
-static void NormalizeIntervalEntries(interval_t input, int64_t &months, int64_t &days, int64_t &micros) {
-	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
-	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
-	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
-	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
-
-	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;
-	input.micros -= extra_days_micros * Interval::MICROS_PER_DAY;
-
-	months = input.months + extra_months_d + extra_months_micros;
-	days = input.days + extra_days_micros;
-	micros = input.micros;
-}
-
-bool Interval::Equals(interval_t left, interval_t right) {
-	return left.months == right.months && left.days == right.days && left.micros == right.micros;
-}
-
-bool Interval::GreaterThan(interval_t left, interval_t right) {
-	int64_t lmonths, ldays, lmicros;
-	int64_t rmonths, rdays, rmicros;
-	NormalizeIntervalEntries(left, lmonths, ldays, lmicros);
-	NormalizeIntervalEntries(right, rmonths, rdays, rmicros);
-
-	if (lmonths > rmonths) {
-		return true;
-	} else if (lmonths < rmonths) {
-		return false;
-	}
-	if (ldays > rdays) {
-		return true;
-	} else if (ldays < rdays) {
-		return false;
-	}
-	return lmicros > rmicros;
-}
-
-bool Interval::GreaterThanEquals(interval_t left, interval_t right) {
-	return GreaterThan(left, right) || Equals(left, right);
-}
-
 interval_t Interval::Invert(interval_t interval) {
 	interval.days = -interval.days;
 	interval.micros = -interval.micros;