duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

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

@@ -10,34 +10,61 @@ static char ComputePadding(idx_t len) {
 }
 
 idx_t Bit::ComputeBitstringLen(idx_t len) {
-	len = len % 8 ? (len / 8) + 1 : len / 8;
-	return ++len; // additional first byte to store info on zero padding
+	idx_t result = len / 8;
+	if (len % 8 != 0) {
+		result++;
+	}
+	// additional first byte to store info on zero padding
+	result++;
+	return result;
 }
 
-inline idx_t Bit::GetPadding(const string_t &bit_string) {
-	auto data = (const_data_ptr_t)bit_string.GetDataUnsafe();
+static inline idx_t GetBitPadding(const string_t &bit_string) {
+	auto data = (const_data_ptr_t)bit_string.GetData();
+	D_ASSERT(idx_t(data[0]) <= 8);
 	return data[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 str_len;
+}
+
+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);
+}
+
 void Bit::SetEmptyBitString(string_t &target, string_t &input) {
 	char *res_buf = target.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 	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 data = (const_data_ptr_t)bits.GetData();
 	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';
@@ -51,13 +78,13 @@ void Bit::ToString(string_t bits, char *output) {
 
 string Bit::ToString(string_t str) {
 	auto len = BitLength(str);
-	auto buffer = std::unique_ptr<char[]>(new char[len]);
+	auto buffer = unique_ptr<char[]>(new char[len]);
 	ToString(str, buffer.get());
 	return string(buffer.get(), len);
 }
 
 bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -79,18 +106,10 @@ bool Bit::TryGetBitStringSize(string_t str, idx_t &str_len, string *error_messag
 	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);
-	}
-	return str_len;
-}
-
-void Bit::ToBit(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+void Bit::ToBit(string_t str, string_t &output_str) {
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
+	auto output = output_str.GetDataWriteable();
 
 	char byte = 0;
 	idx_t padded_byte = len % 8;
@@ -115,33 +134,38 @@ 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);
+	auto buffer = unique_ptr<char[]>(new char[bit_len]);
+	string_t output_str(buffer.get(), bit_len);
+	Bit::ToBit(str, output_str);
+	return output_str.GetString();
 }
 
 // **** scalar functions ****
-void Bit::BitString(const string_t &input, const idx_t &len, string_t &result) {
+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();
+	const char *buf = input.GetData();
 
-	res_buf[0] = ComputePadding(len);
-	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
-		if (i < len - input.GetSize()) {
+	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 - (len - input.GetSize())] == '1' ? 1 : 0;
+			idx_t bit = buf[i - (bit_length - input.GetSize())] == '1' ? 1 : 0;
 			Bit::SetBit(result, i, bit);
 		}
 	}
+	Bit::Finalize(result);
 }
 
 idx_t Bit::BitLength(string_t bits) {
-	return ((bits.GetSize() - 1) * 8) - GetPadding(bits);
+	return ((bits.GetSize() - 1) * 8) - GetBitPadding(bits);
 }
 
 idx_t Bit::OctetLength(string_t bits) {
@@ -150,27 +174,27 @@ idx_t Bit::OctetLength(string_t bits) {
 
 idx_t Bit::BitCount(string_t bits) {
 	idx_t count = 0;
-	const char *buf = bits.GetDataUnsafe();
+	const char *buf = bits.GetData();
 	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;
+	return count - GetBitPadding(bits);
 }
 
 idx_t Bit::BitPosition(string_t substring, string_t bits) {
-	const char *buf = bits.GetDataUnsafe();
+	const char *buf = bits.GetData();
 	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++) {
+	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 - GetPadding(bits)) - substr_len + 2;
+				return (bit_idx - GetBitPadding(bits)) - substr_len + 2;
 			}
 		} else {
 			substr_idx = 0;
@@ -183,7 +207,7 @@ idx_t Bit::BitPosition(string_t substring, string_t bits) {
 			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;
+					return (((byte_idx - 1) * 8) + bit_idx - GetBitPadding(bits)) - substr_len + 2;
 				}
 			} else {
 				substr_idx = 0;
@@ -194,45 +218,43 @@ idx_t Bit::BitPosition(string_t substring, string_t bits) {
 }
 
 idx_t Bit::GetBit(string_t bit_string, idx_t n) {
-	const char *buf = bit_string.GetDataUnsafe();
-	n += GetPadding(bit_string);
-
-	char byte = buf[(n / 8) + 1] >> (7 - (n % 8));
-	return (byte & 1 ? 1 : 0);
+	return Bit::GetBitInternal(bit_string, n + GetBitPadding(bit_string));
 }
 
-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::GetBitIndex(idx_t n) {
+	return n / 8 + 1;
+}
 
-	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::GetBitInternal(string_t bit_string, idx_t n) {
+	const char *buf = bit_string.GetData();
+	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;
 	}
 }
 
 // **** 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();
+	const char *buf = bit_string.GetData();
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
 		if (i < shift) {
@@ -242,11 +264,12 @@ 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) {
 	char *res_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetDataUnsafe();
+	const char *buf = bit_string.GetData();
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(bit_string); i++) {
 		if (i < (Bit::BitLength(bit_string) - shift)) {
@@ -256,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) {
@@ -264,13 +289,15 @@ void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	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) {
@@ -279,13 +306,15 @@ void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	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) {
@@ -294,22 +323,35 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 	}
 
 	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetDataUnsafe();
-	const char *l_buf = lhs.GetDataUnsafe();
+	const char *r_buf = rhs.GetData();
+	const char *l_buf = lhs.GetData();
 
 	buf[0] = l_buf[0];
 	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) {
 	char *result_buf = result.GetDataWriteable();
-	const char *buf = input.GetDataUnsafe();
+	const char *buf = input.GetData();
 
 	result_buf[0] = buf[0];
 	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,11 +20,11 @@ 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) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto data = (const_data_ptr_t)blob.GetData();
 	auto len = blob.GetSize();
 	idx_t str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -40,7 +40,7 @@ idx_t Blob::GetStringSize(string_t blob) {
 }
 
 void Blob::ToString(string_t blob, char *output) {
-	auto data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto data = (const_data_ptr_t)blob.GetData();
 	auto len = blob.GetSize();
 	idx_t str_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -64,13 +64,13 @@ void Blob::ToString(string_t blob, char *output) {
 
 string Blob::ToString(string_t blob) {
 	auto str_len = GetStringSize(blob);
-	auto buffer = std::unique_ptr<char[]>(new char[str_len]);
+	auto buffer = unique_ptr<char[]>(new char[str_len]);
 	Blob::ToString(blob, buffer.get());
 	return string(buffer.get(), str_len);
 }
 
 bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -112,7 +112,7 @@ idx_t Blob::GetBlobSize(string_t str) {
 }
 
 void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto data = (const_data_ptr_t)str.GetData();
 	auto len = str.GetSize();
 	idx_t blob_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -136,7 +136,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 
 string Blob::ToBlob(string_t str) {
 	auto blob_len = GetBlobSize(str);
-	auto buffer = std::unique_ptr<char[]>(new char[blob_len]);
+	auto buffer = unique_ptr<char[]>(new char[blob_len]);
 	Blob::ToBlob(str, (data_ptr_t)buffer.get());
 	return string(buffer.get(), blob_len);
 }
@@ -149,7 +149,7 @@ idx_t Blob::ToBase64Size(string_t blob) {
 }
 
 void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = (const_data_ptr_t)blob.GetDataUnsafe();
+	auto input_data = (const_data_ptr_t)blob.GetData();
 	auto input_size = blob.GetSize();
 	idx_t out_idx = 0;
 	idx_t i;
@@ -192,7 +192,7 @@ static constexpr int BASE64_DECODING_TABLE[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};
 
 idx_t Blob::FromBase64Size(string_t str) {
-	auto input_data = str.GetDataUnsafe();
+	auto input_data = str.GetData();
 	auto input_size = str.GetSize();
 	if (input_size % 4 != 0) {
 		// valid base64 needs to always be cleanly divisible by 4
@@ -239,7 +239,7 @@ uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx
 
 void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
 	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = (const_data_ptr_t)str.GetDataUnsafe();
+	auto input_data = (const_data_ptr_t)str.GetData();
 	auto input_size = str.GetSize();
 	if (input_size == 0) {
 		return;

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

@@ -119,7 +119,7 @@ void ChunkCollection::Append(DataChunk &new_chunk) {
 
 	if (remaining_data > 0) {
 		// create a new chunk and fill it with the remainder
-		auto chunk = make_unique<DataChunk>();
+		auto chunk = make_uniq<DataChunk>();
 		chunk->Initialize(allocator, types);
 		new_chunk.Copy(*chunk, offset);
 		chunks.push_back(std::move(chunk));
@@ -139,11 +139,11 @@ void ChunkCollection::Fuse(ChunkCollection &other) {
 	if (count == 0) {
 		chunks.reserve(other.ChunkCount());
 		for (idx_t chunk_idx = 0; chunk_idx < other.ChunkCount(); ++chunk_idx) {
-			auto lhs = make_unique<DataChunk>();
+			auto lhs = make_uniq<DataChunk>();
 			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_allocator.cpp → column/column_data_allocator.cpp}

@@ -1,7 +1,8 @@
-#include "duckdb/common/types/column_data_allocator.hpp"
+#include "duckdb/common/types/column/column_data_allocator.hpp"
 
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/storage/buffer/block_handle.hpp"
 
 namespace duckdb {
 
@@ -196,7 +197,7 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	D_ASSERT(i < end);
 
 	auto base_ptr = (char *)GetDataPointer(state, block_id, offset);
-	if (strings[i].GetDataUnsafe() == base_ptr) {
+	if (strings[i].GetData() == base_ptr) {
 		// pointers are still valid
 		return;
 	}

package/src/duckdb/src/common/types/{column_data_collection.cpp → column/column_data_collection.cpp}

@@ -1,8 +1,9 @@
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
+#include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 
@@ -92,7 +93,7 @@ void ColumnDataCollection::Initialize(vector<LogicalType> types_p) {
 }
 
 void ColumnDataCollection::CreateSegment() {
-	segments.emplace_back(make_unique<ColumnDataCollectionSegment>(allocator, types));
+	segments.emplace_back(make_uniq<ColumnDataCollectionSegment>(allocator, types));
 }
 
 Allocator &ColumnDataCollection::GetAllocator() const {
@@ -127,7 +128,7 @@ ColumnDataRowCollection::ColumnDataRowCollection(const ColumnDataCollection &col
 	ColumnDataScanState temp_scan_state;
 	collection.InitializeScan(temp_scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY);
 	while (true) {
-		auto chunk = make_unique<DataChunk>();
+		auto chunk = make_uniq<DataChunk>();
 		collection.InitializeScanChunk(*chunk);
 		if (!collection.Scan(temp_scan_state, *chunk)) {
 			break;
@@ -518,7 +519,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 				target_entry = source_entry;
 			} else {
 				D_ASSERT(heap_ptr != nullptr);
-				memcpy(heap_ptr, source_entry.GetDataUnsafe(), source_entry.GetSize());
+				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
 				target_entry = string_t((const char *)heap_ptr, source_entry.GetSize());
 				heap_ptr += source_entry.GetSize();
 			}
@@ -886,6 +887,7 @@ void ColumnDataCollection::Combine(ColumnDataCollection &other) {
 	for (auto &other_seg : other.segments) {
 		segments.push_back(std::move(other_seg));
 	}
+	other.Reset();
 	Verify();
 }
 
@@ -929,7 +931,24 @@ void ColumnDataCollection::Verify() {
 }
 
 string ColumnDataCollection::ToString() const {
-	return "Column Data Collection";
+	DataChunk chunk;
+	InitializeScanChunk(chunk);
+
+	ColumnDataScanState scan_state;
+	InitializeScan(scan_state);
+
+	string result = StringUtil::Format("ColumnDataCollection - [%llu Chunks, %llu Rows]\n", ChunkCount(), Count());
+	idx_t chunk_idx = 0;
+	idx_t row_count = 0;
+	while (Scan(scan_state, chunk)) {
+		result +=
+		    StringUtil::Format("Chunk %llu - [Rows %llu - %llu]\n", chunk_idx, row_count, row_count + chunk.size()) +
+		    chunk.ToString();
+		chunk_idx++;
+		row_count += chunk.size();
+	}
+
+	return result;
 }
 
 void ColumnDataCollection::Print() const {
@@ -944,8 +963,14 @@ 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) {
+                                        string &error_message, bool ordered) {
 	if (left.ColumnCount() != right.ColumnCount()) {
 		error_message = "Column count mismatch";
 		return false;
@@ -959,13 +984,48 @@ 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);
+				break;
+			}
+		}
+		if (!error_message.empty()) {
+			if (ordered) {
 				return false;
+			} else {
+				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 → column/column_data_collection_segment.cpp}

@@ -1,4 +1,6 @@
-#include "duckdb/common/types/column_data_collection_segment.hpp"
+#include "duckdb/common/types/column/column_data_collection_segment.hpp"
+
+#include "duckdb/common/vector_operations/vector_operations.hpp"
 
 namespace duckdb {
 
@@ -168,11 +170,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 +201,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/{column_data_consumer.cpp → column/column_data_consumer.cpp}

@@ -1,4 +1,4 @@
-#include "duckdb/common/types/column_data_consumer.hpp"
+#include "duckdb/common/types/column/column_data_consumer.hpp"
 
 #include <algorithm>